Interface LCD 16×2 with STM32 using I2C

The STM32 I2C LCD1602 display is a simple yet powerful way to show text in embedded applications. In this guide, you’ll learn how to connect an I2C LCD with STM32 using the PCF8574 I/O expander and HAL library. By using only SDA and SCL lines, you can reduce GPIO usage and quickly display characters, numbers, and strings on a 16×2 LCD. This tutorial includes working code for lcd_init, lcd_send_cmd, and lcd_send_data, and works perfectly with STM32CubeIDE.

In this tutorial, you’ll learn how to connect and control a 16×2 I2C LCD (LCD1602) with an STM32 microcontroller using the PCF8574 I/O expander. We’ll walk through the wiring setup, explain how the I2C communication works with the LCD, and implement essential HAL functions to initialize the display, send commands, and print characters or strings. The tutorial also provides a clean and reusable code structure compatible with STM32CubeIDE, making it easy to integrate into your own projects.

You can also check out some 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.

What is LCD1602 I2C Display and How It Works with STM32

The LCD1602 is a widely used 16×2 alphanumeric display module capable of showing 2 lines of 16 characters each. The standard module requires at least 6 GPIO pins to interface with a microcontroller, but adding the PCF8574 I/O expander simplifies this by enabling communication over the I²C bus using just two lines—SDA and SCL. This greatly reduces wiring complexity and conserves GPIO resources on the STM32 or any microcontroller. The PCF8574 handles parallel-to-serial data conversion, making the setup ideal for compact or resource-constrained embedded systems.

Some of its important features are:

• I²C Communication: Reduces pin count from 6+ to just 2 (SDA and SCL), freeing up valuable MCU GPIOs.
• Built-in Backlight and Contrast Control: Allows brightness adjustment and contrast tuning using onboard trimpots or software.
• Compact and Readable Display: Displays 16 characters × 2 lines, suitable for status messages, sensor values, and basic UI.
• Wide Compatibility: Works seamlessly with STM32, Arduino, ESP32, and other microcontrollers through I²C protocols.

Why should you use the LCD16x2 Display ?

The LCD16x2 display is a simple yet highly effective solution for showing text-based information in embedded systems. It’s ideal for projects that need basic human-readable output without the complexity or resource demands of graphical displays. Whether you’re displaying sensor data, system status, or debug messages, the LCD16x2 offers a reliable and cost-efficient option. Its wide availability, low power consumption, and straightforward interfacing make it a go-to choice for hobbyists and professionals alike.

Reasons to Use the LCD16x2 Display

• Easy to Interface – Works with 4-bit/8-bit parallel or I²C using PCF8574.
• Low Power Consumption – Suitable for battery-powered and low-power applications.
• Cost-Effective – Very affordable for displaying basic textual output.
• Readability – Sharp contrast and backlight make it easy to read even in low light.
• Widely Supported – Compatible with STM32, Arduino, ESP32, and many platforms.
• No Complex Libraries Needed – Simple functions like send command/data are enough to operate.

PCF8574 I2C Address Configuration Explained

The PCF8574 I/O Expander works with the I2C protocol, and every device on the I2C bus needs a unique address. The PCF8574 default address is fixed at the higher 4 bits (0100), while the lower 3 bits (A2, A1, A0) can be changed to avoid conflicts.

Why change the PCF8574 I2C address?

If you use only one PCF8574 chip, you don’t need to change its address. However, when you connect multiple devices—such as two or more I2C LCD1602 displays—you must assign different I2C addresses to each chip. Otherwise, address conflicts will occur, and the devices will not work properly on the same I2C bus.

PCF8574 Address Format

The address structure looks like this:
0100 A2 A1 A0 R/W

• A2, A1, A0 → Selectable address pins
• R/W → Defines Read (1) or Write (0) operation

Default PCF8574 Address

By default, all three pins (A0, A1, A2) are HIGH.

• Default binary address: 0100 1110
• Default hexadecimal address: 0x4E

How to change the PCF8574 address?

To set a new address:

• Connect any of the pins A0, A1, A2 to GND.
• Each change gives you a new valid I2C address.

Example:

• If A0 = GND, the new address becomes 0100 1100 (0x4C).

This way, you can connect up to 8 PCF8574 devices (or 8 LCDs) on the same I2C bus.

Important: The last bit (R/W) is not part of the actual device address. It only tells whether the operation is read or write.

STM32 LCD1602 I2C Project Requirement

I’ve used products mentioned below in this project. I have also added affiliate links for your convenience — if you purchase through these links, it helps support my work at no extra cost to you.

• STM32 development board
• 16×2 I2C LCD module
• 10 kΩ potentiometer for contrast
• Jumper wires and
• Breadboard

STM32 LCD1602 I2C Schematic and Pinout (PCF8574 Module)

The image below shows the PCF8574 module which connects at the back of the LCD 16×2.

The first pin of the device is Vss which is pin 1 of LCD. So all you have to do is connect first pins of the LCD to Vss above and rest of them will connect accordingly. Starting with Vss as first pin, connection is as follows:-

The 16 pins from the PCF8574 module are connected to the LCD16x2. The connection with the STM32 is shown in the table below.

STM32CubeMX Configuration

In this section, we’ll set up STM32CubeMX for I2C communication, pin mapping, clock settings, and code generation to prepare the project.

STM32 Clock Configuration

Below is the image showing the clock configuration for the project.

The STM32F103 is clocked by the external 8MHz crystal. We will use the PLL to run the system at maximum 72MHz clock.

LCD16x2 I2C Configuration

Below is the image showing the I2C configuraion.

I am using the I2C1 to connect the LCD. The I2C is configured in the standard mode, with the clock speed set to 100KHz.
The pins PB6 and PB7 are configured as the SCL and SDA pins. These pins are connected to the respective pins of the PCF8574 as shown in the connection diagram.

STM32 I2C LCD1602 HAL Code Example

Let’s take a detailed look at the pinout of the PCF8574.

As you can see above,

• P0 is connected to the pin RS of the LCD. This RS pin is defines whether the transmitted byte is a command (0) or Data (1).
• P1 is connected to the R/W pin of the LCD. This pin should be LOW when writing the data to the LCD and HIGH when reading the data from the LCD.
• P2 is connected to the Enable pin of the LCD. This pin is used for the strobe (E=1 & E=0).
• P3 is connected to the Backlight of the Display. Setting this pin to 1 will turn the backlight ON.
• P4 – P7 are connected to the data pins D4 – D7. Since only 4 data pins are available in the PCF8574, we need to configure the LCD in the 4bit Mode.

PCF8574 Address Definition

#define SLAVE_ADDRESS_LCD 0x4E // change this according to ur setup

#define SLAVE_ADDRESS_LCD 0x4E // change this according to ur setup

The default slave address defined in the i2c-lcd.c is 0x4E. This is default Address for the PCF8574, if the pins A0 A1 and A2 are not modified. It is already explained above in the Address section.

Sending LCD 16×2 Command

The function below actively sends a command byte to the LCD using the PCF8574 I2C expander in 4-bit mode.

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

    uint8_t data_t[4];

    // send upper 4 bits with enable pulse
    data_t[0] = data_u | 0x0C;   // EN=1, RS=0  -> bxxxx1100
    data_t[1] = data_u | 0x08;   // EN=0, RS=0  -> bxxxx1000

    // send lower 4 bits with enable pulse
    data_t[2] = data_l | 0x0C;   // EN=1, RS=0  -> bxxxx1100
    data_t[3] = data_l | 0x08;   // EN=0, RS=0  -> bxxxx1000

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

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

    uint8_t data_t[4];

    // send upper 4 bits with enable pulse
    data_t[0] = data_u | 0x0C;   // EN=1, RS=0  -> bxxxx1100
    data_t[1] = data_u | 0x08;   // EN=0, RS=0  -> bxxxx1000

    // send lower 4 bits with enable pulse
    data_t[2] = data_l | 0x0C;   // EN=1, RS=0  -> bxxxx1100
    data_t[3] = data_l | 0x08;   // EN=0, RS=0  -> bxxxx1000

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

Step-by-Step Explanation

• This function accepts a command byte as its input parameter.
• Because the LCD runs in 4-bit mode, the function immediately splits the command into two parts:
  • The upper 4 bits (data_u)
  • The lower 4 bits (data_l)
• Then, the function processes each part separately before transmitting it via I2C communication.

PCF8574 Pin Mapping

As explained in the image above, the PCF8574 I/O expander controls the LCD through its 8 pins (P0–P7). Here is the mapping:

• P0 → RS (Register Select): set RS = 0 for command mode.
• P1 → R/W (Read/Write): always 0 because we only write.
• P2 → EN (Enable pin): toggled high and low to strobe data.
• P3 → Backlight control: set to 1 to keep the LCD backlight ON.
• P4–P7 → Data lines (D4–D7): carry the actual 4-bit data.

By controlling these pins, we actively manage how each command reaches the LCD.

How the Function Sends Data

To transmit data reliably, the function uses a strobe method:

1. Send the upper 4 bits first
   • Set EN = 1 → latch the data
   • Set EN = 0 → complete the transfer
   • This process follows the LCD datasheet requirement.
2. Send the lower 4 bits next
   • Again, toggle EN from 1 to 0 to ensure proper latching.
3. Transmit all 4 bytes via I2C
   • The function finally calls HAL_I2C_Master_Transmit to send the 4 prepared bytes to the LCD using the STM32 I2C peripheral.

Why This Function Works

Because the LCD only accepts 4 bits at a time in 4-bit mode, this function ensures smooth data transfer. It actively splits the command, applies the correct PCF8574 pin configuration, and strobes the enable pin at the right moments. As a result, the LCD receives each command correctly and performs the desired operation.

Sending LCD16x2 Data

The data is sent in the similar manner as the command. The only difference is that the RS bit (P0) will be 1. This is to indicate that the transmitted byte is a data byte.

void lcd_send_data (char data)
{
	char data_u, data_l;
	uint8_t data_t[4];
	data_u = (data&0xf0);
	data_l = ((data<<4)&0xf0);
	data_t[0] = data_u|0x0D;  //en=1, rs=1 -> bxxxx1101
	data_t[1] = data_u|0x09;  //en=0, rs=1 -> bxxxx1001
	data_t[2] = data_l|0x0D;  //en=1, rs=1 -> bxxxx1101
	data_t[3] = data_l|0x09;  //en=0, rs=1 -> bxxxx1001
	HAL_I2C_Master_Transmit (&hi2c1, SLAVE_ADDRESS_LCD,(uint8_t *) data_t, 4, 100);
}

void lcd_send_data (char data)
{
	char data_u, data_l;
	uint8_t data_t[4];
	data_u = (data&0xf0);
	data_l = ((data<<4)&0xf0);
	data_t[0] = data_u|0x0D;  //en=1, rs=1 -> bxxxx1101
	data_t[1] = data_u|0x09;  //en=0, rs=1 -> bxxxx1001
	data_t[2] = data_l|0x0D;  //en=1, rs=1 -> bxxxx1101
	data_t[3] = data_l|0x09;  //en=0, rs=1 -> bxxxx1001
	HAL_I2C_Master_Transmit (&hi2c1, SLAVE_ADDRESS_LCD,(uint8_t *) data_t, 4, 100);
}

Initialize I2C LCD16x2

Below is the function to initialise the LCD in the 4bit mode. The initialisation requires us to send a few set of command in a particular order. These commands and sequence are provided in the LCD1602 Datasheet. The code below is commented properly, so you can understand what is the function of each command.

void lcd_init (void)
{
  // 4 bit initialisation
  HAL_Delay(50);  // wait for >40ms
  lcd_send_cmd (0x30);
  HAL_Delay(5);  // wait for >4.1ms
  lcd_send_cmd (0x30);
  HAL_Delay(1);  // wait for >100us
  lcd_send_cmd (0x30);
  HAL_Delay(10);
  lcd_send_cmd (0x20);  // 4bit mode
  HAL_Delay(10);

  // display initialisation
  lcd_send_cmd (0x28); // Function set --> DL=0 (4 bit mode), N = 1 (2 line display) F = 0 (5x8 characters)
  HAL_Delay(1);
  lcd_send_cmd (0x08); //Display on/off control --> D=0,C=0, B=0  ---> display off
  HAL_Delay(1);
  lcd_send_cmd (0x01);  // clear display
  HAL_Delay(2);
  lcd_send_cmd (0x06); //Entry mode set --> I/D = 1 (increment cursor) & S = 0 (no shift)
  HAL_Delay(1);
  lcd_send_cmd (0x0C); //Display on/off control --> D = 1, C and B = 0. (Cursor and blink, last two bits)
}

void lcd_init (void)
{
  // 4 bit initialisation
  HAL_Delay(50);  // wait for >40ms
  lcd_send_cmd (0x30);
  HAL_Delay(5);  // wait for >4.1ms
  lcd_send_cmd (0x30);
  HAL_Delay(1);  // wait for >100us
  lcd_send_cmd (0x30);
  HAL_Delay(10);
  lcd_send_cmd (0x20);  // 4bit mode
  HAL_Delay(10);

  // display initialisation
  lcd_send_cmd (0x28); // Function set --> DL=0 (4 bit mode), N = 1 (2 line display) F = 0 (5x8 characters)
  HAL_Delay(1);
  lcd_send_cmd (0x08); //Display on/off control --> D=0,C=0, B=0  ---> display off
  HAL_Delay(1);
  lcd_send_cmd (0x01);  // clear display
  HAL_Delay(2);
  lcd_send_cmd (0x06); //Entry mode set --> I/D = 1 (increment cursor) & S = 0 (no shift)
  HAL_Delay(1);
  lcd_send_cmd (0x0C); //Display on/off control --> D = 1, C and B = 0. (Cursor and blink, last two bits)
}

The above code is with reference to the pattern given for the initialization in the datasheet of the device.

Basically the function initializes the LCD in 4-bit mode.

• It starts with delays and 0x30 commands to ensure the LCD resets properly, then switches to 4-bit mode with 0x20.
• Next, it configures the display with 0x28 (4-bit, 2-line, 5×8 font).
• It turns the display off (0x08), clears it (0x01), sets entry mode (0x06, auto-increment cursor, no shift), and finally turns the display on without cursor/blink (0x0C).

Send String to I2C LCD16x2

We can send a single data byte using the function lcd_send_data(), but to send the entire string or a character array, we will write a separate function.

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

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

The function lcd_send_string() can be used to send an entire string to the display. The parameter of this function is the pointer to the string or array, that you want to send.

The loop while (*str) keeps running as long as the current character in the string is not the null terminator. In other words, it processes each character of the string one by one until the end.

Set Cursor Position on LCD16x2

The function lcd_put_cur() moves the cursor to a specific row and column of the LCD.

void lcd_put_cur(int row, int col)
{
    switch (row)
    {
        case 0:
            col |= 0x80;
            break;
        case 1:
            col |= 0xC0;
            break;
    }
    lcd_send_cmd (col);
}

void lcd_put_cur(int row, int col)
{
    switch (row)
    {
        case 0:
            col |= 0x80;
            break;
        case 1:
            col |= 0xC0;
            break;
    }
    lcd_send_cmd (col);
}

For a 16×2 LCD:

• Row 0 starts at DDRAM address 0x00 → Command = (0x80 | col)
• Row 1 starts at DDRAM address 0x40 → Command = (0x80 | 0x40 | col) → (0xC0 | col)

For Example: lcd_put_cur(1,3) → cursor goes to row 1, column 3 (0xC3).

STM32 LCD16x2 HAL main() function

Now we will print some data on the LCD16x2 display using our functions inside the main function of the STM32 project.

Print Strings

We will first see how to print the strings on the display.

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

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

In the main function we will

• Initialise the LCD by calling lcd_init() function.
• Now put the cursor at the beginning of the 1^st Row (0,0) and send the string “HELLO WORLD” to this location.
• Next put the cursor at the beginning of the 2^nd Row (1,0) and send the string “from CTECH” to this location.

Below is the output of the above code.

Print Number

We cannot print a number directly on the LCD16x2 display. By default, the display can only show ASCII characters. Therefore, before sending a number to the LCD, we must first convert the number into its ASCII representation. After conversion, the LCD can print it just like any other character or string.

Below is the code to convert and print the number.

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

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

In the main function we will

• Initialise the LCD by calling lcd_init() function.
• Let’s say we want to print the number 1234, which has 4 digits. Therefore, define a character buffer to store 1 extra byte, i.e 5 bytes.
• Now we will use sprintf to convert the number to the character for and store it in the array we just defined.
  • The format specifier, %d, is used to convert integer values to character form.
• Next, put the cursor at the beginning of the 1^st Row (0,0) and send the array.

Below is the output of the above code.

Print Floats

Just like numbers, we can not print the floats directly on the display. Therefore, we need to convert the float value to the Ascii form and then print it.

Below is the code to convert and print the float.

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

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

In the main function we will

• Initialise the LCD by calling lcd_init() function.
• Let’s say we want to print the number 12.345. It has 6 digits, so define a character buffer to store 1 extra byte, i.e 7 bytes.
• Now we will use sprintf to convert the float to the character for and store it in the array we just defined.
  • The format specifier %.3f is used to convert float values to character form, till 3 decimal places.
• Next put the cursor at the beginning of the 1^st Row (0,0) and send the array.

Below is the output of the above code.

This STM32 I2C LCD1602 project shows how to print strings, numbers, and float values using only two pins. With the PCF8574 I2C expander and HAL, you get a scalable, low-GPIO solution ideal for IoT and embedded systems. Moreover, the STM32 LCD I2C method is efficient and easy to extend. However, if you prefer the classic approach, check the parallel LCD16x2 STM32 interface tutorial.

PROJECT DOWNLOAD

FAQs — STM32 LCD 16×2 Using I2C