Interfacing LCD1602 with TM4C123G Tiva C Using I2C (Complete Beginner-Friendly Guide)

Interfacing the LCD1602 display with the TM4C123G Tiva C is one of the easiest ways to add text output to your embedded project. The display works with only two wires when we use the I2C module, which makes the connection simple and clean. You can show messages, numbers, sensor values, and even custom characters.

In this tutorial, we will use TivaWare APIs and create a separate LCD library to keep the code neat. We will start from the basics, like the pinout and wiring. Then we will move to writing text, scrolling messages, and building custom characters. Each step is written in simple words, short sentences, and easy-to-follow code.

Recommended Resources:

I have already covered how to use I2C in TM4C123G. This tutorial is going to be a continuation in this series, so you must read the following tutorial first:

What is LCD1602 I2C Module

The LCD1602 I2C module combines a standard 16×2 character LCD with an I2C backpack. This setup reduces wiring, saves GPIO pins, and makes the display much easier to use with the TM4C123G. Instead of 16 separate connections, you only need two wires: SDA and SCL. This keeps your project clean and beginner-friendly.

LCD1602 Display Overview

The LCD1602 is a simple alphanumeric display. It shows 16 characters per line and 2 lines in total. Each character sits in a 5×8 pixel block.
It can show text, numbers, and custom symbols. The display has a built-in controller, usually the HD44780, which accepts standard commands like clear, home, and cursor control.

I2C Adapter (PCF8574) Overview

The I2C backpack uses the PCF8574 I/O expander. This small chip converts I2C data into 8 digital outputs. These outputs drive the LCD pins internally. The adapter also includes a contrast control potentiometer and backlight control transistor, so you don’t need external parts.
The PCF8574 has a 7Bit default address like 0x27 or 0x3F, depending on the chip version. You can change the address by shorting the A0, A1, and A2 jumpers.

Why Use I2C Instead of 16 Pins

Without I2C, the LCD1602 needs at least 6 GPIO pins, and often more. This consumes valuable pins on the TM4C123G. The I2C module cuts this down to only two pins, which frees up space for sensors and peripherals.
It also makes the wiring simple, reduces mistakes, and allows multiple I2C devices to share the same bus.

LCD1602 I2C Pinout and Connection with TM4C123G

Connecting the LCD1602 I2C display to the TM4C123G is simple because the module uses only two wires for data. You only need to power the display and connect the I2C lines. Once the wiring is done, the display is ready for communication through TivaWare APIs.

LCD1602 I2C Pinout

The I2C version of the LCD1602 comes with a 4-pin header. The pins are:

Many modules run the LCD at 5V, but the SDA/SCL pins are usually pulled up to 5V through the PCF8574 board. Always check your module before connecting.

TM4C123G I2C Pins Used (I2C0 / I2C1 Options)

The TM4C123G has multiple I2C modules. You can use I2C0 or I2C1 for this display.

I2C0 Pinout

I2C1 Pinout

I2C0 is the most commonly used module because most example codes and libraries are based on it. But any I2C module will work as long as you configure the pins correctly in TivaWare.

Complete Wiring Diagram Explanation

The wiring is very simple, you just need to connect the SCL and SDA pins. The image below shows the connection between TM4C123G and LCD1602 I2C module.

The pins are connected as follows:

Make sure the LCD backpack address (0x27 or 0x3F) is correct. You can scan the I2C bus if you are unsure.

Pull-Up Resistors and I2C Voltage Notes

The I2C bus always needs pull-up resistors on SDA and SCL. Most LCD1602 I2C modules already include 4.7kΩ pull-ups on the backpack, so you do not need to add external ones.

Important notes:

• If the module uses 5V pull-ups, the SDA and SCL lines will also be at 5V.
• The TM4C123G is not 5V tolerant, so direct 5V I2C lines can damage the MCU.
• Many PCF8574 boards internally run SDA/SCL at 3.3V even with 5V power. But not all boards do.

For safety, always check:

• Whether your module has 3.3V-safe I2C pull-ups
• Or use a logic level shifter

Once the voltage is correct, the LCD1602 I2C module will communicate reliably with the TM4C123G.

Setting Up I2C in TivaWare

Before we can send any data to the LCD1602 display, we must enable and configure the I2C module on the TM4C123G. The LCD communicates only through I2C, so this setup is necessary. We will use TivaWare APIs because they are simple, reliable, and easy to read.
If you want a deeper explanation of I2C on TM4C123G, you can check my full TM4C123G I2C tutorial on the website.

Enabling I2C Peripheral in TM4C123G

The first step is to enable the I2C module and its GPIO port.
For example, if you use I2C0, you must enable:

• The I2C0 peripheral
• The GPIOB port for PB2 and PB3

TivaWare function used:

SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

A small delay or a wait loop ensures the peripheral is ready before configuration.

Configuring SDA and SCL Pins

Next, we configure the pins for their I2C functions.

For I2C0:

• PB2 : SCL
• PB3 : SDA

TivaWare code snippet:

GPIOPinConfigure(GPIO_PB2_I2C0SCL);
GPIOPinConfigure(GPIO_PB3_I2C0SDA);

GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2);
GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);

GPIOPinConfigure(GPIO_PB2_I2C0SCL);
GPIOPinConfigure(GPIO_PB3_I2C0SDA);

GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2);
GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);

The GPIOPinTypeI2CSCL function configures the SCL pin with the correct open-drain and digital features.
The SDA pin uses GPIOPinTypeI2C.

Initializing I2C Master in TivaWare

After the pins are ready, we set up the I2C master with the desired clock speed. Most LCD1602 I2C modules work perfectly at 100 kHz standard mode.

Example:

I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false);

I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false);

• false : Standard mode (100 kHz)
• true : Fast mode (400 kHz)

Standard mode is recommended for stable LCD communication.

If you need a complete, step-by-step guide on setting up I2C, you can read my full tutorial here:

TM4C123G I2C Tutorial

Complete Function: I2C Setup for TM4C123G (TivaWare)

/*
 * Function: I2C0_Init
 * Purpose : Initialize I2C0 on PB2 (SCL) and PB3 (SDA)
 * Speed   : Standard Mode (100 kHz)
 */
void I2C0_Init(void)
{
    //
    // 1. Enable the I2C0 peripheral and GPIOB port
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

    // Wait until ready
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_I2C0));
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOB));

    //
    // 2. Configure GPIO pins for I2C0
    // PB2 -> I2C0SCL
    // PB3 -> I2C0SDA
    //
    GPIOPinConfigure(GPIO_PB2_I2C0SCL);
    GPIOPinConfigure(GPIO_PB3_I2C0SDA);

    GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2);  // SCL pin setup
    GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);     // SDA pin setup

    //
    // 3. Initialize I2C Master
    // false = Standard Mode (100 kHz)
    // true  = Fast Mode (400 kHz)
    //
    I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false);

    //
    // 4. Clear any previous I2C errors
    //
    I2CMasterEnable(I2C0_BASE);
}

/*
 * Function: I2C0_Init
 * Purpose : Initialize I2C0 on PB2 (SCL) and PB3 (SDA)
 * Speed   : Standard Mode (100 kHz)
 */
void I2C0_Init(void)
{
    //
    // 1. Enable the I2C0 peripheral and GPIOB port
    //
    SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C0);
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

    // Wait until ready
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_I2C0));
    while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOB));

    //
    // 2. Configure GPIO pins for I2C0
    // PB2 -> I2C0SCL
    // PB3 -> I2C0SDA
    //
    GPIOPinConfigure(GPIO_PB2_I2C0SCL);
    GPIOPinConfigure(GPIO_PB3_I2C0SDA);

    GPIOPinTypeI2CSCL(GPIO_PORTB_BASE, GPIO_PIN_2);  // SCL pin setup
    GPIOPinTypeI2C(GPIO_PORTB_BASE, GPIO_PIN_3);     // SDA pin setup

    //
    // 3. Initialize I2C Master
    // false = Standard Mode (100 kHz)
    // true  = Fast Mode (400 kHz)
    //
    I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false);

    //
    // 4. Clear any previous I2C errors
    //
    I2CMasterEnable(I2C0_BASE);
}

Creating LCD1602 I2C Library for TM4C123G

To keep the code clean and easy to manage, we will create a separate library for the LCD1602 I2C display. This library will include all low-level I2C functions, the command functions, and high-level APIs for printing text, numbers, and custom characters. The main file will only call these functions, which makes the project simple to read and maintain.

LCD Library File Structure (lcd1602_i2c.c / .h)

I have created two files:

• lcd1602_i2c.h : Function declarations, macros, and LCD commands
• lcd1602_i2c.c : Function definitions and I2C communication code

This structure keeps the LCD code independent and reusable in any project.

You can download these files along with the project at the bottom of this post. After downloading the project, copy these files to your project.

Your main file will only include:

#include "lcd1602_i2c.h"

#include "lcd1602_i2c.h"

This approach follows best practices and improves readability.

Sending Commands to LCD via I2C

The LCD works by receiving specific command bytes. These commands control actions like clearing the display, moving the cursor, and controlling the backlight.

To send a command, we send two nibbles (high 4 bits and low 4 bits) through the PCF8574 I/O expander. Each nibble must be combined with control bits such as RS = 0 (command mode) and EN = 1/0 to latch the data.

Typical function structure:

void LCD_SendCommand(uint8_t cmd)
{
    // Send high nibble
    // Send low nibble
}

void LCD_SendCommand(uint8_t cmd)
{
    // Send high nibble
    // Send low nibble
}

The function handles the I2C start condition, data transfer, and enable pulse.

Sending Data to LCD

Sending data is similar to sending commands, except here we set RS = 1 to indicate character data.

This function sends the ASCII value of each character to the LCD:

void LCD_SendData(uint8_t data)
{
    // RS = 1, send high nibble
    // RS = 1, send low nibble
}

void LCD_SendData(uint8_t data)
{
    // RS = 1, send high nibble
    // RS = 1, send low nibble
}

This function is used for printing characters, strings, and numbers.

Backlight and Clear Display Commands

Most I2C LCD modules include backlight control through the PCF8574.

• To turn on backlight -> Set BL bit to 1
• To turn off backlight -> Set BL bit to 0

The library includes simple helper functions:

void LCD_BacklightOn(void);
void LCD_BacklightOff(void);

void LCD_BacklightOn(void);
void LCD_BacklightOff(void);

The clear display command resets the LCD and moves the cursor to the home position:

LCD_SendCommand(0x01);  // Clear display

LCD_SendCommand(0x01);  // Clear display

This command needs a small delay afterward.

LCD Initialization Sequence

The LCD must be initialized with a specific sequence. Without this, the display will not respond correctly.

A typical initialization includes:

1. Set 4-bit mode
2. Turn on display
3. Set cursor settings
4. Clear display
5. Return home

the LCD library have an LCD_Init() function:

void LCD_Init(void)
{
    // Initialize I2C communication
    // Send initialization commands
    // Clear display
}

void LCD_Init(void)
{
    // Initialize I2C communication
    // Send initialization commands
    // Clear display
}

After initialization, the LCD is ready to print text, numbers, and custom characters.

LCD1602 Basic Functions

Working with the LCD becomes much easier once the I2C library is ready. In this part of the tutorial, we will explore the most common LCD functions that help you print text, move the cursor, display numbers, and send characters one by one. These functions are used in almost every LCD project, so understanding them will help you build more advanced applications later.

Let’s begin with the simplest and most frequently used feature: printing a string to the display.

Writing Strings to the LCD

Printing a string on the LCD1602 is one of the most basic tasks. After initializing the system clock, setting up I2C, and starting the LCD, you can display text using a simple function such as:

LCD_PrintString("Hello World!");

LCD_PrintString("Hello World!");

This function takes a character array and sends each character one by one to the LCD using I2C. It is perfect for printing messages, headings, menu titles, or any static text.

Below is a minimal example program that prints “Hello World!” on the LCD.

int main(void)
{
    systemClockConfig();   // Configure system clock for TM4C123G
    I2C0_Init();           // Initialize I2C0 on PB2 (SCL) and PB3 (SDA)
    IntMasterEnable();     // Enable global interrupts (good practice)

    LCD_Init();            // Initialize LCD1602 in 4-bit mode via I2C

    LCD_PrintString("Hello World!");   // Print a basic string

    while(1)
    {
        // Main loop does nothing, LCD keeps showing the text
    }
}

int main(void)
{
    systemClockConfig();   // Configure system clock for TM4C123G
    I2C0_Init();           // Initialize I2C0 on PB2 (SCL) and PB3 (SDA)
    IntMasterEnable();     // Enable global interrupts (good practice)

    LCD_Init();            // Initialize LCD1602 in 4-bit mode via I2C

    LCD_PrintString("Hello World!");   // Print a basic string

    while(1)
    {
        // Main loop does nothing, LCD keeps showing the text
    }
}

Explanation of the Code

• systemClockConfig()
  Sets up the clock speed for the microcontroller. A stable clock is necessary for I2C timing.
  
• I2C0_Init()
  Initializes I2C communication. This configures PB2 and PB3 for SCL and SDA and sets the master speed.
  
• IntMasterEnable()
  Enables MCU interrupts globally. Some library functions depend on it.
  
• LCD_Init()
  Sends the LCD initialization sequence. This prepares the LCD in 4-bit mode, clears the display, and turns on the backlight.
  
• LCD_PrintString(“Hello World!”)
  Sends each character of the string to the LCD. Internally, this function loops through the characters and uses I2C write commands.
  
• while(1)
  The LCD keeps showing the content without needing constant refreshing.

This is the simplest way to get your first message on the LCD1602.

Program Output

The image below shows the output of the code:

After running the program, the LCD displays the message “Hello World!” on the first line. The backlight turns on automatically during initialization, and the cursor remains hidden unless explicitly enabled. This confirms that the I2C communication is working correctly and the LCD library is functioning as expected.

Displaying Numbers, Floats, and Using Cursor Positioning

After printing simple text, the next useful feature is displaying numbers, floating-point values, and placing text at specific positions on the LCD. These functions are very important when working with real projects such as sensor readings, timers, ADC values, and menus.

To achieve this, your LCD library typically provides three essential functions:

• LCD_SetCursor(row, col) : moves the cursor to a specific location
• LCD_PrintInt(value) : prints integer numbers
• LCD_PrintFloat(value) : prints decimal values with controlled precision

Below is a simple program that prints an integer on the first row and a floating-point number on the second row. It also uses the cursor-positioning function before printing.

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Print integer on Row 0, Column 0
    LCD_SetCursor(0, 0);
    LCD_PrintInt(1234);

    // Print float on Row 1, Column 0
    LCD_SetCursor(1, 0);
    LCD_PrintFloat(3.1416, 3);

    while(1)
    {
    }
}

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Print integer on Row 0, Column 0
    LCD_SetCursor(0, 0);
    LCD_PrintInt(1234);

    // Print float on Row 1, Column 0
    LCD_SetCursor(1, 0);
    LCD_PrintFloat(3.1416, 3);

    while(1)
    {
    }
}

Explanation of the Code

• LCD_SetCursor(row, col)
  Positions the cursor at the given row and column.
  • Rows: 0 or 1
  • Columns: 0 to 15
    Once the cursor is set, the next printed character will appear at that position.
    
• LCD_PrintInt(1234)
  Converts the integer 1234 into a string using sprintf() or another method, then sends it to the LCD.
  
• LCD_PrintFloat(3.1416, 3)
  Converts a floating-point value into a formatted string with up to three decimal places.
  A custom function has been added to the library to perform this conversion without relying on sprintf.

Program Output

The image below shows the output of the code:

The top row displays the integer 1234, and the second row shows the floating-point number. Both values appear exactly at the chosen cursor positions, confirming that the cursor function and numeric printing functions work correctly.

Advanced LCD1602 Features

Once you understand the basic LCD functions, you can move on to more advanced features that make your projects look polished and professional. These features allow you to scroll text smoothly, control the backlight, and clear the display whenever needed. Let’s explore them one by one with simple explanations.

Scrolling Text Left and Right

Scrolling is a powerful feature when your message is longer than 16 characters. It helps create dynamic displays and UI effects.

Your library may include commands such as:

LCD_ScrollLeft();
LCD_ScrollRight();

LCD_ScrollLeft();
LCD_ScrollRight();

These functions use the LCD’s display shift commands. Each call shifts the entire screen by one position. You can place them inside a loop with a delay to create smooth motion:

    while(1)
    {
        LCD_PrintString("Hello World from TM4C123G..");
        delay_ms(500);
        int i=0;
        for(i=0; i < 40; i++) // scroll for the entire string length
        {
            LCD_ScrollLeft();
            delay_ms(500);
        }
        LCD_Clear();
    }

    while(1)
    {
        LCD_PrintString("Hello World from TM4C123G..");
        delay_ms(500);
        int i=0;
        for(i=0; i < 40; i++) // scroll for the entire string length
        {
            LCD_ScrollLeft();
            delay_ms(500);
        }
        LCD_Clear();
    }

This is useful for:

• Long names
• Sensor logs
• Notification effects
• Animated titles

Turning Backlight On and Off

The I2C adapter (PCF8574) also controls the LCD’s backlight.
Your library may offer two simple functions:

LCD_BacklightOn();
LCD_BacklightOff();

LCD_BacklightOn();
LCD_BacklightOff();

These functions toggle a bit inside the PCF8574 output register. They are useful when:

• Saving power
• Dimming the display when inactive
• Highlighting certain events (blink the backlight)

Controlling the backlight through software makes your LCD interface more interactive.

Clearing the LCD

The LCD1602 provides built-in commands for clearing and resetting the display.

You may find functions like:

LCD_Clear();

LCD_Clear();

LCD_Clear()

• Clears the entire screen
• Moves cursor to home position (0,0)
• Takes a short delay because the LCD needs time to process it

Creating Custom Characters on LCD1602 I2C

The HD44780 LCD controller supports up to 8 custom characters, stored inside the CGRAM (Character Generator RAM). These characters allow you to display icons such as arrows, battery indicators, smileys, loading bars, and any symbol you design yourself.

Each custom character is a 5×8 pixel pattern, represented using an array of 8 bytes.
Each bit in a byte turns a pixel ON (1) or OFF (0).

Once a custom character is stored in CGRAM, you can display it on the LCD using:

LCD_SendData(location);   // where location = 0 to 7

LCD_SendData(location);   // where location = 0 to 7

Example: Creating a Single Custom Character

Let’s create a simple smiley face.

Character Definition (5×8 pixels)

uint8_t smiley[8] = {
    0b00000,
    0b01010,
    0b01010,
    0b00000,
    0b10001,
    0b01110,
    0b00000,
    0b00000
};

uint8_t smiley[8] = {
    0b00000,
    0b01010,
    0b01010,
    0b00000,
    0b10001,
    0b01110,
    0b00000,
    0b00000
};

Main Program:

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Load custom character at location 0
    LCD_CreateChar(0, smiley);

    LCD_SetCursor(0, 0);
    LCD_PrintString("Have a nice day");

    LCD_SetCursor(1, 7);
    LCD_SendData(0);   // Display the custom character

    while(1)
    {
    }
}

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Load custom character at location 0
    LCD_CreateChar(0, smiley);

    LCD_SetCursor(0, 0);
    LCD_PrintString("Have a nice day");

    LCD_SetCursor(1, 7);
    LCD_SendData(0);   // Display the custom character

    while(1)
    {
    }
}

Explanation of the Code

• LCD_CreateChar(0, smiley);
  Stores the smiley icon in CGRAM slot 0
  
• LCD_SendData(0);
  Prints the custom character stored in location 0
  
• The custom character remains available until:
  • The LCD is reinitialized, or
  • Power is removed

This method allows you to design any small icon and display it anywhere on the LCD.

Output on the LCD

The image below shows the output of the code.
A smiley icon appears at the end of the second row, while the first row prints the main message.

Below the smiley, you can clearly see how the custom pixel pattern is displayed exactly as defined.

Example: Creating Multiple Custom Characters

uint8_t icon1[8] = {0x00,0x0A,0x0A,0x00,0x11,0x0E,0x00,0x00}; // Smiley
uint8_t icon2[8] = {0x04,0x0E,0x15,0x04,0x04,0x04,0x04,0x00}; // Arrow Up
uint8_t icon3[8] = {0x04,0x04,0x04,0x04,0x15,0x0E,0x04,0x00}; // Arrow Down
uint8_t icon4[8] = {0x00,0x04,0x0E,0x1F,0x0E,0x04,0x00,0x00}; // Heart

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Load multiple custom characters
    LCD_CreateChar(0, icon1);
    LCD_CreateChar(1, icon2);
    LCD_CreateChar(2, icon3);
    LCD_CreateChar(3, icon4);

    LCD_SetCursor(0,0);
    LCD_PrintString("Custom Icons:");

    LCD_SetCursor(1,3);
    LCD_SendData(0);
    LCD_SendData(1);
    LCD_SendData(2);
    LCD_SendData(3);

    while(1)
    {
    }
}

uint8_t icon1[8] = {0x00,0x0A,0x0A,0x00,0x11,0x0E,0x00,0x00}; // Smiley
uint8_t icon2[8] = {0x04,0x0E,0x15,0x04,0x04,0x04,0x04,0x00}; // Arrow Up
uint8_t icon3[8] = {0x04,0x04,0x04,0x04,0x15,0x0E,0x04,0x00}; // Arrow Down
uint8_t icon4[8] = {0x00,0x04,0x0E,0x1F,0x0E,0x04,0x00,0x00}; // Heart

int main(void)
{
    systemClockConfig();
    I2C0_Init();
    IntMasterEnable();

    LCD_Init();

    // Load multiple custom characters
    LCD_CreateChar(0, icon1);
    LCD_CreateChar(1, icon2);
    LCD_CreateChar(2, icon3);
    LCD_CreateChar(3, icon4);

    LCD_SetCursor(0,0);
    LCD_PrintString("Custom Icons:");

    LCD_SetCursor(1,3);
    LCD_SendData(0);
    LCD_SendData(1);
    LCD_SendData(2);
    LCD_SendData(3);

    while(1)
    {
    }
}

Explanation of the Code

• Four custom characters are stored in CGRAM slots 0–3
• After writing them, the program displays all four icons on the second row
• Custom characters can be used for menus, graphical indicators, UI symbols, etc.

The image below shows the result on the LCD1602 display.
The first row prints text while the custom icons appear in the second row.

Output on the LCD

You can clearly see the smiley, arrow up, arrow down, and heart icons—all created using CGRAM.

LCD1602 5×8 Custom Character Generator

You can generate the custom characters using the tool below. Click on the squares to toggle pixels ON (black) or OFF (white). After finishing your design, click “Generate Code” to get the Arduino byte array.

Common Errors and Troubleshooting

Working with the LCD1602 over I2C is usually simple, but a few common problems can appear during testing. Most issues come from wiring mistakes, incorrect addresses, or an incomplete LCD initialization. This section will help you quickly diagnose and fix the most frequent errors you may face while using the LCD1602 I2C module with the TM4C123G.

Wrong I2C Address Issue

The LCD will not respond if the I2C address is wrong. Many LCD1602 I2C modules use 0x27, but some use 0x3F depending on the PCF8574 chip version.

Symptoms:

• LCD stays blank
• No characters appear
• Code gets stuck waiting for I2C
• No ACK received on the bus

Fixes:

• Check the I2C address printed on the I2C backpack (sometimes marked as PCF8574 or PCF8574A)
• If unsure, scan the I2C bus using a simple I2C scanner code
• Change the address inside your LCD library:

#define LCD_I2C_ADDR 0x27
// or use 0x3F depending on your module

#define LCD_I2C_ADDR 0x27
// or use 0x3F depending on your module

Once the correct address is used, the LCD will start responding.

Display Not Turning On

If the LCD does not glow or show blocks on the first row, the backlight or power wiring may be incorrect.

Symptoms:

• LCD appears completely dead
• No backlight
• Initialization commands do nothing

Fixes:

• Ensure VCC = 5V and GND are connected properly
• Make sure the module’s backlight jumper is present (some modules have a removable jumper)
• Confirm the USB cable or power supply is not too weak
• Verify I2C pull-up resistors exist (either on the board or externally)

Once power is stable, the LCD should at least show a row of dark blocks before initialization.

Characters Not Printing Correctly

Sometimes characters appear as random symbols or completely distorted on the screen.

Symptoms:

• Garbled characters
• Wrong symbols instead of your text
• Letters overlapping or broken
• Cursor placed at unexpected locations

Fixes:

• Recheck your LCD initialization sequence
• Ensure the LCD_SendCmd() and LCD_SendData() functions send nibbles in the correct order
• Make sure the Enable (EN) pulse timing is correct
• Avoid sending text before calling LCD_Init()
• Try reducing I2C speed to 100 kHz:

I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false); // Standard mode

I2CMasterInitExpClk(I2C0_BASE, SysCtlClockGet(), false); // Standard mode

Bad timing or incomplete initialization is the most common cause of corrupted characters.

Fixing Contrast and Backlight Problems

The LCD’s visibility depends on proper contrast and backlight settings. If the text appears too faint or not visible at all, the contrast is usually misadjusted.

Symptoms:

• Very dim characters
• No text but backlight ON
• Blocks visible only at certain angles
• Display visible only when pressed

Fixes:

• Adjust the contrast potentiometer on the I2C backpack
  • Rotate until text becomes sharp
• Enable or disable the backlight using your library:

LCD_BacklightOn();
// or
LCD_BacklightOff();

LCD_BacklightOn();
// or
LCD_BacklightOff();

• Ensure LCD receives a clean 5V supply
• Avoid powering the LCD from unstable USB ports

Proper contrast adjustment almost always fixes the visibility issue.

Conclusion

In this tutorial, we explored how to interface the LCD1602 display with the TM4C123G using the I2C protocol. We started from the basics—pinout, wiring, and I2C setup—then built a clean and reusable LCD library. You learned how to send commands, print text, position the cursor, show numbers and floats, and even create custom characters using CGRAM. Each step was explained with simple code examples so you can quickly apply these functions in your projects.

We also moved into more advanced features such as scrolling text, controlling the backlight, and resetting or clearing the display. These features allow you to create richer user interfaces, menus, and dynamic updates on the LCD. With this foundation, you can now adapt the display to fit a wide range of applications such as sensor dashboards, system logs, user prompts, or debugging information.

Finally, we looked at common errors and the best ways to troubleshoot them—whether it’s the wrong I2C address, wiring issues, contrast adjustments, or communication errors. With all these tools in hand, you now have a complete guide to using the LCD1602 I2C module efficiently with the TM4C123G. This knowledge will save time in your future projects and help you build cleaner, more professional embedded systems.

TM4C123G LaunchPad Tutorial: Setup CCS Studio and Build Your First Program

TM4C123G Clock Setup Tutorial – Configure System Clock with PLL

TM4C123G Delay Tutorial – Using SysCtlDelay and SysTick Timer

TM4C123 GPIO Tutorial – Digital Input and Output using Tiva C LaunchPad

TM4C123 GPIO External Interrupts (Using TivaWare in Code Composer Studio)

TM4C123G UART Tutorial (PART 1) – How to Use UART and Virtual COM Port in Tiva C

TM4C123G UART Tutorial (PART 2): Use Interrupt to Receive Data and Control LEDs

I2C in TM4C123G Tiva C – How to Use I2C Peripheral with TivaWare

1 2 Next »