How to Use an I2C LCD Display (16x2) with Arduino, ESP32 and Pico

The 16x2 LCD, which shows 2 rows of 16 characters, is the most common display in the Arduino world. It's used to show readings such as temperature and distance, menus, clocks and game scores. The display itself has 16 pins and needs at least 6 digital pins on its own; the small I2C module soldered to its back brings that down to just 2 data wires. In this post you'll see, step by step, how to connect an I2C LCD, find its address and print whatever you want on it.

How does an LCD display work?

These displays run on a driver chip called the HD44780. Each character is drawn in a small 5x8-pixel box, and the chip contains a built-in character table of letters, digits and some symbols. The Arduino only sends a command like "write this letter at this position"; turning the letter into pixels is the display's job. The LED backlight makes the text readable in the dark, while the liquid crystal layer forms the text by darkening pixels.

What is I2C and why does it make things easier?

I2C is a way for several devices to talk over two wires: SDA carries the data and SCL carries the clock signal. Every device has its own address, and the Arduino calls the device it wants by that address. LCD modules usually use address 0x27 or 0x3F. A clock module, an OLED display and sensors such as the BME280 can share the same two wires; as long as their addresses differ, they all work together.

The PCF8574 chip on the module converts commands arriving over I2C into the 8 parallel signals the display expects. You can use the display without an I2C module, but then you need 6 pins, a potentiometer and lots of wires. The module saves pins and keeps your circuit tidy.

Specifications

I2C LCD wiring: Arduino, ESP32 and Pico

The wiring is the same four wires on every board; the only thing that changes is which pins SDA and SCL are on. To see your board's I2C pins, check the Pinout tool.

Finding the I2C address: scanner sketch

If you're not sure of your display's address, upload the code below. It tries every address from 1 to 126 and prints the address of each device that answers to the Serial Monitor. You'll use this address when you set up the display.

1#include <Wire.h>
2
3void setup() {
4  Wire.begin();
5  Serial.begin(9600);
6  Serial.println("I2C taranıyor / scanning...");
7  for (byte addr = 1; addr < 127; addr++) {
8    Wire.beginTransmission(addr);
9    if (Wire.endTransmission() == 0) {   // cihaz cevap verdi / device answered
10      Serial.print("Bulundu / found: 0x");
11      Serial.println(addr, HEX);
12    }
13  }
14}
15
16void loop() {
17}

Installing the library and printing text

In the Library Manager, search for LiquidCrystal I2C and install the library by Frank de Brabander. The code below writes a greeting on the first row and, on the second row, the number of seconds since the Arduino started.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);  // adres, sütun, satır / address, columns, rows
5
6void setup() {
7  lcd.init();
8  lcd.backlight();               // arka ışığı aç / backlight on
9  lcd.setCursor(0, 0);           // sütun 0, satır 0 / column 0, row 0
10  lcd.print("Merhaba Dunya!");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);           // ikinci satır / second row
15  lcd.print("Sure: ");
16  lcd.print(millis() / 1000);    // saniye / seconds
17  lcd.print(" sn   ");           // eski rakamları sil / clear old digits
18  delay(200);
19}

The most useful LCD commands

Scrolling text

To show text longer than 16 characters, you can scroll the display. The code below prints the text and shifts it left every 300 milliseconds, so a long message flows across the screen like a sign.

1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3
4LiquidCrystal_I2C lcd(0x27, 16, 2);
5
6void setup() {
7  lcd.init();
8  lcd.backlight();
9  lcd.print("BlueGrays ile elektronik ogren");  // 16 karakterden uzun / longer than 16 chars
10}
11
12void loop() {
13  lcd.scrollDisplayLeft();   // bir adım sola / one step left
14  delay(300);
15}

Custom characters and special letters

The HD44780 character table has no accented letters such as ş, ğ, ı, ö, ü, ç (or é and ñ); if you try to print them you'll see meaningless symbols. The solution is to define up to 8 custom 5x8-pixel characters. Each row is written as one byte, and the bits set to 1 are the lit pixels. The example below draws a heart; you can draw any accented letter the same way.

1byte heart[8] = {
2  0b00000,
3  0b01010,
4  0b11111,
5  0b11111,
6  0b01110,
7  0b00100,
8  0b00000,
9  0b00000
10};
11
12// setup() içinde / inside setup()
13lcd.createChar(0, heart);   // 0. yuvaya kaydet / store in slot 0
14lcd.setCursor(15, 0);
15lcd.write(byte(0));         // kalbi göster / show the heart

I2C LCD with the ESP32 and Raspberry Pi Pico

On the ESP32 the same Arduino code and library work; Wire.begin() uses GPIO 21 (SDA) and GPIO 22 (SCL) by default. If you want different pins, write Wire.begin(SDA, SCL). On the Raspberry Pi Pico with MicroPython, copy two small files called lcd_api.py and pico_i2c_lcd.py to the Pico and use them like this:

1from machine import I2C, Pin
2from pico_i2c_lcd import I2cLcd   # Pico'ya kopyalanan dosya / file copied to the Pico
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5addr = i2c.scan()[0]              # ilk bulunan adres / first found address
6lcd = I2cLcd(i2c, addr, 2, 16)    # 2 satır, 16 sütun / 2 rows, 16 columns
7
8lcd.putstr("Merhaba Pico!")
9lcd.move_to(0, 1)                 # sütun 0, satır 1 / column 0, row 1
10lcd.putstr("BlueGrays")

I2C LCD project ideas

• Digital thermometer: show temperature and humidity on the display; for the sensor side see DHT11 Temperature and Humidity Sensor.
• Distance display: show the distance measured with an HC-SR04 in centimetres; details in HC-SR04 Distance Sensor.
• Digital voltmeter: show the voltage you read from an analog pin.
• Code lock: show the code typed on a keypad as asterisks.
• Menu system: move through options on the display with a potentiometer or two buttons.
• Mini game: make a runner drawn with custom characters dodge obstacles.

Common mistakes and how to fix them

• Display lit but no text: the contrast isn't set; turn the trimpot.
• Solid blocks on the top row: the display has power but hasn't been initialised; the address may be wrong, SDA and SCL may be swapped, or lcd.init() wasn't called.
• Wrong address: the code says 0x27 but the display is 0x3F; find the real address with the scanner sketch.
• Old digits left behind: a number dropping from 100 to 99 shows up as 990; print a few spaces after the number. lcd.clear() also works but is slow, and the display flickers if you call it often in the loop.
• Garbled accented letters: they aren't in the display's table; define custom characters or avoid them.
• Text randomly corrupted: long, loose wires or noisy parts such as motors can disturb the I2C bus; keep wires short and power motors from a separate supply.

Pairing the display with a sensor is the quickest way to build your first real project. In the BlueGrays app you'll find dozens of I2C LCD projects with circuit diagrams and ready-to-use code, and to change values with a knob, What Is a Potentiometer? will come in handy.