Raspberry Pi I2C LCD Setup: Bus Mechanics, PCF8574 Wiring, and Python Code

To connect an LCD to a Raspberry Pi via I2C, you need a standard 16x2 (or 20x4) HD44780 display equipped with a PCF8574 I2C backpack, four jumper wires, and the RPLCD Python library. The default I2C address is usually 0x27, and the bus operates on the Pi's hardware I2C pins (SDA on GPIO 2, SCL on GPIO 3). While the physical connection takes less than a minute, the electrical reality of mixing 5V LCD logic with the Raspberry Pi's strict 3.3V GPIO architecture requires specific pull-up resistor management to avoid silicon damage.

I2C Bus Mechanics and the PCF8574 Backpack

The Inter-Integrated Circuit (I2C) protocol is a synchronous, multi-master, multi-slave serial communication bus. Unlike SPI, which requires a dedicated chip-select wire for every peripheral, I2C uses a shared two-wire bus, making it ideal for low-speed, short-distance sensor and display networks. When you attach an HD44780 LCD to a Pi, you aren't actually talking to the LCD controller directly; you are talking to the PCF8574 I/O expander on the backpack, which then bit-bangs the parallel data into the LCD.

Below is the definitive specification matrix for the I2C bus as it applies to the PCF8574 LCD backpack ecosystem. This data is derived from the NXP I2C-bus specification (UM10204) and standard PCF8574 datasheets.

Physical Wiring and the 5V/3.3V Pull-Up Trap

The most common mistake makers make when wiring an I2C LCD to a Raspberry Pi is ignoring the voltage mismatch. The Raspberry Pi's BCM2711 (Pi 4) and BCM2712 (Pi 5) SoCs operate at strictly 3.3V logic. Feeding 5V into a GPIO pin will permanently damage the silicon. However, almost all generic PCF8574 backpacks sold online are designed for 5V Arduino Unos.

Here is the physical wiring map for a Raspberry Pi 4 or 5:

• Pin 2 (5V Power): Connect to Backpack VCC (Required to power the LCD backlight LED and the PCF8574 chip).
• Pin 6 (Ground): Connect to Backpack GND.
• Pin 3 (GPIO 2 / SDA1): Connect to Backpack SDA.
• Pin 5 (GPIO 3 / SCL1): Connect to Backpack SCL.

The Pull-Up Resistor Hazard

I2C uses an open-drain architecture. Devices only pull the line LOW (to GND); they never actively drive it HIGH. The HIGH state is achieved via pull-up resistors tied to the voltage rail. The Raspberry Pi has internal 1.8kΩ pull-up resistors tied to its 3.3V rail. The PCF8574 backpack has external 10kΩ pull-up resistors tied to its 5V VCC rail.

If you wire this directly, the backpack's 10k resistors will attempt to pull the Pi's SDA and SCL lines up to 5V. While the Pi's internal 1.8k resistors to 3.3V create a voltage divider that might keep the actual voltage around 3.8V, this still violates the Pi's absolute maximum ratings and causes long-term reliability issues.

Python Exchange: Driving the Display with RPLCD

Once the physical layer is secure and the pull-up hazard is mitigated, you need to enable the I2C interface on the Pi. Run sudo raspi-config, navigate to Interface Options > I2C, and enable it. Reboot the Pi.

For the software exchange, skip the outdated smbus raw byte-pushing tutorials. The modern standard is the RPLCD library, which abstracts the PCF8574 pin mapping and HD44780 initialization commands into clean Python methods.

Install the library via pip:

pip install RPLCD

Below is a minimal, complete working exchange. This script initializes the bus, clears the screen, writes a string, and creates a custom character (a degree symbol) to demonstrate direct CGRAM access.

from RPLCD.i2c import CharLCD
import time

# Initialize the LCD. 
# address=0x27 is standard for PCF8574. Use 0x3F if you have a PCF8574A chip.
# port=1 is the default hardware I2C bus on modern Raspberry Pis.
lcd = CharLCD(i2c_expander='PCF8574', address=0x27, port=1,
              cols=16, rows=2, dotsize=8,
              charset='A00', auto_linebreaks=True)

# Define a custom degree symbol (°)
degree_symbol = [
    0b01100,
    0b10010,
    0b10010,
    0b01100,
    0b00000,
    0b00000,
    0b00000,
    0b00000
]
lcd.create_char(0, degree_symbol)

# Clear display and write text
lcd.clear()
lcd.cursor_pos = (0, 0)
lcd.write_string('ElectricalFlux')

lcd.cursor_pos = (1, 0)
lcd.write_string('Temp: 24.5\x00C') # \x00 calls custom char 0

time.sleep(5)
lcd.clear()
lcd.backlight = False # Turn off backlight to save power

Sniffing the Bus and Classic I2C Failures

When the screen stays blank, the issue is almost always at the physical or addressing layer, not in your Python code. Before rewriting your script, you must sniff the bus to verify the Pi actually sees the backpack.

Open your terminal and run the I2C detection tool:

sudo i2cdetect -y 1

This command scans the bus and outputs a grid of addresses. If your LCD is wired correctly, you will see 27 or 3f in the grid. If you see UU, the kernel has already claimed the device (rare for LCDs, common for RTCs). If the grid is entirely blank, you have a physical layer failure.

By treating the I2C bus as a physical electrical circuit rather than just a software abstraction, you eliminate 90% of the headaches associated with Raspberry Pi LCD projects. Verify your pull-up voltages, confirm your address with i2cdetect, and let the RPLCD library handle the heavy lifting of the HD44780 instruction set.