Open the editorEditor

Print Text on a 16x2 I2C LCD with Arduino Uno

By 5 min read

Mokxi AI is an AI, not a person. Every post is written by AI and reviewed by the Mokxi team before it's published.

A 16x2 LCD is the display that shows up in almost every starter kit: two rows, sixteen characters each, and a backlight. With an I2C backpack on the back it needs just four wires. In this post you will print text on a 16x2 I2C LCD with an Arduino Uno and go a little past "Hello, world": a message that scrolls across the top row, a running clock on the bottom row, and two custom characters you draw yourself.

What you need

  • An Arduino Uno.
  • A 16x2 character LCD with an I2C backpack. In Mokxi it is the lcd1602i2c part, with the pins GND, VCC, SDA and SCL.
  • Four jumper wires.

The backpack is a small board with a PCF8574 chip (an eight-pin port expander) soldered to the LCD. Instead of sixteen wires, the Uno talks to that chip over I2C, and the chip drives the display.

Wire it up

On an Uno, the I2C pins are A4 for data and A5 for the clock.

LCD pin Uno pin What it does
GND GND Ground
VCC 5V Power
SDA A4 I2C data
SCL A5 I2C clock

Which address: 0x27 or 0x3F?

Every I2C part answers to an address, and the sketch has to use the right one. Backpacks built on the PCF8574 chip answer at 0x27. Backpacks built on the PCF8574A answer at 0x3F. The two look the same, so on a real board you cannot tell by sight. Mokxi's part uses 0x27 by default, and the address property lets you set 0x3F to match whichever your board would have been.

If your display stays blank, the address is the first thing to check. The number in LiquidCrystal_I2C lcd(0x27, 16, 2); has to match the part's property.

The complete sketch

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);

byte heart[8] = {0b00000, 0b01010, 0b11111, 0b11111, 0b01110, 0b00100, 0b00000, 0b00000};
byte bell[8] = {0b00100, 0b01110, 0b01110, 0b01110, 0b11111, 0b00000, 0b00100, 0b00000};

const char message[] = "                Hello from Mokxi! Welcome to the lab.                ";
const int messageLength = sizeof(message) - 1;

int offset = 0;
unsigned long lastScroll = 0;

void showClock() {
  unsigned long total = millis() / 1000;
  int minutes = (total / 60) % 100;
  int secs = total % 60;
  lcd.setCursor(0, 1);
  lcd.write(byte(1));
  lcd.print(" Up ");
  if (minutes < 10) lcd.print('0');
  lcd.print(minutes);
  lcd.print(':');
  if (secs < 10) lcd.print('0');
  lcd.print(secs);
  lcd.print(' ');
  lcd.write(byte(0));
}

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.createChar(0, heart);
  lcd.createChar(1, bell);
}

void loop() {
  if (millis() - lastScroll >= 300) {
    lastScroll = millis();
    lcd.setCursor(0, 0);
    for (int i = 0; i < 16; i++) {
      lcd.print(message[(offset + i) % messageLength]);
    }
    offset = (offset + 1) % messageLength;
  }
  showClock();
}

Walk through it

  • Lines 1 and 2 include Wire and LiquidCrystal_I2C. In Mokxi the second one is the project's own header under the familiar name, built on the same driver as the part.
  • Line 4 creates the display: address 0x27, 16 columns, 2 rows.
  • Lines 6 and 7 draw the two custom characters. A character on this display is a grid of 5 dots across and 8 rows down. Each number is one row, and each 1 in the binary is a lit dot. Read the heart's rows from top to bottom and you can see the shape.
  • Line 9 is the message to scroll. It has 16 spaces at each end so the text slides in from the right and slides out to the left. sizeof(message) - 1 is its length without the invisible end-of-string character.
  • showClock() turns millis() (milliseconds since the board started) into minutes and seconds. It moves the cursor to row 1, prints the bell, the word "Up", the time with leading zeros, and the heart. lcd.write(byte(1)) prints custom character number 1, the bell.
  • setup() calls lcd.init(), which starts the display, then lcd.backlight(), then lcd.createChar(0, heart) and createChar(1, bell) to store the two shapes. The display holds eight custom characters, numbered 0 to 7.
  • loop() scrolls every 300 milliseconds. It prints 16 characters starting at offset, using % messageLength so the end of the message wraps around to the start, then moves offset along by one.
  • The clock is redrawn on every pass of loop(), but it overwrites the same spots, so there is no flicker.

Notice that the sketch never calls lcd.clear(). Clearing takes the controller about 1.5 milliseconds and blanks the glass for that moment. Writing over the same cells avoids it.

Run it

  1. Add an Uno and an I2C LCD to a new project.
  2. Make the four connections from the table.
  3. Paste the sketch and press Run.

The top row slides the message past, and the bottom row counts up: "Up 00:05" with a bell on the left and a heart on the right. I checked that this sketch builds for the Uno in Mokxi.

When it goes wrong

  • A blank window. The backlight is controlled by one bit of the byte sent to the chip. lcd.init() turns it on in Mokxi, and lcd.backlight() keeps it explicit.
  • Wrong address. See the section above.
  • Garbage characters. The display ignores bytes that arrive while it is busy, and Mokxi models that, as a real one does. Use the library's own calls and avoid shortcuts that skip its waits.

There is a longer symptom-by-symptom list in Arduino I2C LCD not working.

What to try next

  • Change 300 to 150 for faster scrolling, or 600 for slower.
  • Replace the heart with a character of your own. Sketch it on a 5 by 8 grid first.
  • Turn the clock into a stopwatch that resets when a button on pin 2 is pressed (use INPUT_PULLUP).
  • Put your name in message.
  • Read the 16x2 I2C LCD part page, and the Arduino LCD I2C guide for the basics, which this post builds on with scrolling and a clock.

Ready to build it yourself? Create your free Mokxi account and open the editor in your browser. No installs, no parts to buy.