Interface I2C LCD1602 (PCF8574) with STM32 HAL & CubeIDE

Wiring a 16×2 LCD to STM32 with 6+ GPIO pins is messy. The PCF8574 I2C expander cuts that down to just two pins — SDA and SCL — while the HAL library handles all the low-level I2C transactions.

This tutorial shows you how to interface an I2C LCD1602 with an STM32F103 using the PCF8574 expander, STM32CubeMX, and CubeIDE with HAL. You’ll configure I2C in CubeMX, understand the PCF8574 address and pin mapping, and write HAL code to display strings, integers, and floats on the LCD. The complete CubeIDE project is available to download below.

If you’re working with other displays, also check out the STM32 LCD tutorials collection and the STM32 OLED tutorials for SPI/I2C OLED options.

You can also check out other Displays interfaced with STM32 Microcontrollers:

• Interface LCD 20×4 with STM32 using the I²C
• Interface LCD1602 display with built‑in I²C driver AIP31068
• Interface SSD1306 OLED Display with STM32 (via I²C)
• Interface SH1106 1.3″ OLED with STM32 via I²C
• Interface LCD 16×2 with STM32 without I²C
• Interface 2.8″ ILI9341 Display with STM32 using SPI

How I2C LCD1602 Works with PCF8574

The PCF8574 is an 8-bit I/O expander that bridges your STM32’s I2C bus to the parallel interface of a 16×2 LCD. Because it uses only SDA and SCL, you save six or more GPIO pins compared to a direct parallel connection.

PCF8574 I2C Address — Default & How to Change It

Every device on the I2C bus needs a unique 7-bit address. The PCF8574’s address uses the fixed upper nibble 0100, while the lower three bits are set by hardware pins A2, A1, A0 on the module.

Default address (A0, A1, A2 all HIGH): Binary: 0100 1110 → Hex: 0x4E

To change the address, pull any of A0–A2 to GND:

This allows up to 8 PCF8574 devices on one I2C bus. Note: the R/W bit is the 8th bit of the transmitted byte, not part of the address itself.

PCF8574 Pin Mapping to LCD1602

The PCF8574 exposes pins P0–P7, which map to the LCD1602 control and data lines:

Because only four data lines are available, the library always operates in 4-bit mode and transmits each byte as two back-to-back nibbles.

Wiring STM32 to I2C LCD (PCF8574)

Schematic & Connection Table

The PCF8574 module mounts directly onto the back of the LCD1602 header. Connect the module to your STM32F103 as follows:

CubeMX Setup, HAL Code & Results

STM32 Clock Configuration

The STM32F103 is clocked from an 8 MHz external crystal. Enable the PLL multiplier to reach the maximum 72 MHz system clock. I2C timing is derived from the APB1 bus, so verify APB1 does not exceed 36 MHz.

I2C1 Configuration

Enable I2C1 in CubeMX and set:

• Mode: I2C
• Speed: Standard Mode, 100 kHz
• Pins: PB6 (SCL), PB7 (SDA) (auto-assigned)

Generate the code. CubeMX will create hi2c1 and the MX_I2C1_Init() function in main.c.

lcd_send_cmd() — Sending Commands

The LCD is operated in 4-bit mode, so every command byte is split into two nibbles and transmitted as four bytes over I2C (upper nibble EN-high, upper nibble EN-low, lower nibble EN-high, lower nibble EN-low).

void lcd_send_cmd(char cmd)
{
    char data_u = (cmd & 0xF0);           // upper nibble
    char data_l = ((cmd << 4) & 0xF0);   // lower nibble

    uint8_t data_t[4];
    data_t[0] = data_u | 0x0C;   // EN=1, RS=0
    data_t[1] = data_u | 0x08;   // EN=0, RS=0
    data_t[2] = data_l | 0x0C;   // EN=1, RS=0
    data_t[3] = data_l | 0x08;   // EN=0, RS=0

    HAL_I2C_Master_Transmit(&hi2c1, SLAVE_ADDRESS_LCD,
                             (uint8_t *)data_t, 4, 100);
}

void lcd_send_cmd(char cmd)
{
    char data_u = (cmd & 0xF0);           // upper nibble
    char data_l = ((cmd << 4) & 0xF0);   // lower nibble

    uint8_t data_t[4];
    data_t[0] = data_u | 0x0C;   // EN=1, RS=0
    data_t[1] = data_u | 0x08;   // EN=0, RS=0
    data_t[2] = data_l | 0x0C;   // EN=1, RS=0
    data_t[3] = data_l | 0x08;   // EN=0, RS=0

    HAL_I2C_Master_Transmit(&hi2c1, SLAVE_ADDRESS_LCD,
                             (uint8_t *)data_t, 4, 100);
}

The mask 0x0C sets EN (P2) and Backlight (P3) HIGH while keeping RS (P0) LOW, signalling a command transaction. EN is then pulled LOW in the next byte to clock the data into the LCD.

lcd_send_data() — Sending Data

Identical nibble-split approach, but RS (P0) is set HIGH (0x0D / 0x09) to tell the LCD the byte is character data, not a command.

void lcd_send_data(char data)
{
    char data_u = (data & 0xF0);
    char data_l = ((data << 4) & 0xF0);
    uint8_t data_t[4];
    data_t[0] = data_u | 0x0D;   // EN=1, RS=1
    data_t[1] = data_u | 0x09;   // EN=0, RS=1
    data_t[2] = data_l | 0x0D;   // EN=1, RS=1
    data_t[3] = data_l | 0x09;   // EN=0, RS=1
    HAL_I2C_Master_Transmit(&hi2c1, SLAVE_ADDRESS_LCD,
                             (uint8_t *)data_t, 4, 100);
}

void lcd_send_data(char data)
{
    char data_u = (data & 0xF0);
    char data_l = ((data << 4) & 0xF0);
    uint8_t data_t[4];
    data_t[0] = data_u | 0x0D;   // EN=1, RS=1
    data_t[1] = data_u | 0x09;   // EN=0, RS=1
    data_t[2] = data_l | 0x0D;   // EN=1, RS=1
    data_t[3] = data_l | 0x09;   // EN=0, RS=1
    HAL_I2C_Master_Transmit(&hi2c1, SLAVE_ADDRESS_LCD,
                             (uint8_t *)data_t, 4, 100);
}

lcd_init() — Initialization Sequence

The initialization sequence follows the LCD1602 datasheet’s 4-bit startup procedure exactly:

void lcd_init(void)
{
    HAL_Delay(50);          // >40 ms power-on delay
    lcd_send_cmd(0x30);
    HAL_Delay(5);           // >4.1 ms
    lcd_send_cmd(0x30);
    HAL_Delay(1);           // >100 µs
    lcd_send_cmd(0x30);
    HAL_Delay(10);
    lcd_send_cmd(0x20);     // switch to 4-bit mode

    lcd_send_cmd(0x28);     // 4-bit, 2-line, 5×8 font
    HAL_Delay(1);
    lcd_send_cmd(0x08);     // display OFF
    HAL_Delay(1);
    lcd_send_cmd(0x01);     // clear display
    HAL_Delay(2);
    lcd_send_cmd(0x06);     // entry mode: cursor increment, no shift
    HAL_Delay(1);
    lcd_send_cmd(0x0C);     // display ON, cursor OFF, blink OFF
}

void lcd_init(void)
{
    HAL_Delay(50);          // >40 ms power-on delay
    lcd_send_cmd(0x30);
    HAL_Delay(5);           // >4.1 ms
    lcd_send_cmd(0x30);
    HAL_Delay(1);           // >100 µs
    lcd_send_cmd(0x30);
    HAL_Delay(10);
    lcd_send_cmd(0x20);     // switch to 4-bit mode

    lcd_send_cmd(0x28);     // 4-bit, 2-line, 5×8 font
    HAL_Delay(1);
    lcd_send_cmd(0x08);     // display OFF
    HAL_Delay(1);
    lcd_send_cmd(0x01);     // clear display
    HAL_Delay(2);
    lcd_send_cmd(0x06);     // entry mode: cursor increment, no shift
    HAL_Delay(1);
    lcd_send_cmd(0x0C);     // display ON, cursor OFF, blink OFF
}

lcd_send_string() — Printing Strings

void lcd_send_string(char *str)
{
    while (*str) lcd_send_data(*str++);
}

void lcd_send_string(char *str)
{
    while (*str) lcd_send_data(*str++);
}

Iterates over each character until the null terminator, calling lcd_send_data() for each byte.

lcd_put_cur() — Setting Cursor Position

void lcd_put_cur(int row, int col)
{
    switch (row)
    {
        case 0: col |= 0x80; break;  // DDRAM row 0 starts at 0x00
        case 1: col |= 0xC0; break;  // DDRAM row 1 starts at 0x40
    }
    lcd_send_cmd(col);
}

void lcd_put_cur(int row, int col)
{
    switch (row)
    {
        case 0: col |= 0x80; break;  // DDRAM row 0 starts at 0x00
        case 1: col |= 0xC0; break;  // DDRAM row 1 starts at 0x40
    }
    lcd_send_cmd(col);
}

Row 0, column 0 → command 0x80. Row 1, column 3 → command 0xC3.

main() — Print Strings, Numbers & Floats

Print a String

lcd_init();
lcd_put_cur(0, 0);
lcd_send_string("HELLO WORLD");
lcd_put_cur(1, 0);
lcd_send_string("from CTECH");

lcd_init();
lcd_put_cur(0, 0);
lcd_send_string("HELLO WORLD");
lcd_put_cur(1, 0);
lcd_send_string("from CTECH");

Print an Integer

The LCD only accepts ASCII, so use sprintf to convert before sending:

lcd_init();
int num = 1234;
char numChar[5];
sprintf(numChar, "%d", num);
lcd_put_cur(0, 0);
lcd_send_string(numChar);

lcd_init();
int num = 1234;
char numChar[5];
sprintf(numChar, "%d", num);
lcd_put_cur(0, 0);
lcd_send_string(numChar);

Buffer size = number of digits + 1 for the null terminator. Use %d for signed integers.

Print a Float

lcd_init();
float flt = 12.345;
char fltChar[7];
sprintf(fltChar, "%.3f", flt);
lcd_put_cur(0, 0);
lcd_send_string(fltChar);

lcd_init();
float flt = 12.345;
char fltChar[7];
sprintf(fltChar, "%.3f", flt);
lcd_put_cur(0, 0);
lcd_send_string(fltChar);

%.3f formats to three decimal places. Buffer size accounts for sign, digits, decimal point, decimals, and null terminator.

STM32 I2C LCD1602 (PCF8574): FAQs

Interfacing a 16×2 LCD over I2C using the PCF8574 is one of the most GPIO-efficient display setups you can build on an STM32. Two pins, a small HAL library, and a straightforward CubeMX configuration are all you need to print strings, integers, and floats on screen.

The same lcd_send_cmd() / lcd_send_data() pattern scales cleanly — swap in a different I2C peripheral, adjust SLAVE_ADDRESS_LCD, and the library works as-is. For projects where you need a larger panel, the same technique applies to the 20×4 I2C LCD on STM32. If GPIO count isn’t a constraint, the parallel LCD1602 tutorial covers the direct 8-bit and 4-bit wiring approach.

Download the complete CubeIDE project below, including the i2c-lcd.c/.h library and the main.c examples for strings, integers, and floats.

STM32 Internal RTC Tutorial: Setup, Alarm, LCD Display & VBAT

LCD 20X4 using I2C with STM32

How to interface MPU6050 (GY-521) with STM32

GLCD 128×64 ST7920 interfacing with STM32

Interface 16×2 LCD with STM32 (No I2C) — 4-bit Guide

Custom characters in LCD 1602 || STM32

1 2 Next »

About the Author

Arun Rawat

Embedded Systems Engineer · Founder, ControllersTech

Arun is an embedded systems engineer with 10+ years of experience in STM32, ESP32, and AVR microcontrollers. He created ControllersTech to share practical tutorials on embedded software, HAL drivers, RTOS, and hardware design — grounded in real industrial automation experience.

About YouTube GitHub Facebook Instagram Shop