Skip to Content

Arduino and ILI9486 LCD Display Module – A Complete Guide

Arduino and ILI9486 LCD Display Module – A Complete Guide

In this tutorial I will show you how to connect and Arduino UNO and a ILI9486 TFT Display.

The ILI9486 is a popular display controller designed to drive LCD screens with a resolution of up to 320×480 pixels.

It boasts many features, including support for 16.7M colors, on-chip display RAM, and an RGB interface that enables high-speed data transfer.

One of the most significant advantages of the ILI9486 is its compatibility with a wide range of microcontrollers, including the popular Arduino boards. 

With this chip, you can easily create various applications such as digital picture frames, gaming consoles, and more.

Whether you are an experienced designer or an enthusiastic hobbyist, the ILI9486 chip is an excellent solution for driving high-resolution displays

So, grab your breadboard, and let’s get started!

Components Needed To Build Arduino And ILI9486 LCD Controller Project

Hardware Components

Software

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com.

Basics of The ILI9486 LCD Driver

The ILI9486 is a high-performance 480×320-pixel resolution TFT LCD controller. It’s designed to provide high-quality images on mobile devices, tablets, and other consumer electronics. 

With a built-in memory interface, it can support display resolutions up to 320×480 pixels, with a refresh rate of up to 60 FPS (frames per second).

One of the key features of the ILI9486 is its compatibility with a wide range of color depths, including 18-bit (262k colors) and 16-bit (65k colors) modes.

It supports various image and display formats, including JPEG, BMP, and GIF.

In the below table, you can find all the supported communication modes of the ILI9486 LCD driver.

communication modes of the ILI9486 LCD driver

The ILI9486 supports multiple modes of communication. You can control the mode using three pins (IM2-0). The mode option enables you to connect the LCD controller to various MCUs.

The controller includes several advanced features, including:

  • gamma correction, 
  • a built-in oscillator, 
  • and a programmable display interface. 

The gamma correction feature provides improved color reproduction and accuracy, while the built-in oscillator provides precise timing control for the display. 

The ILI9486 controller includes a parallel RGB interface, which enables it to interface with a wide range of microcontrollers and processors. 

The ILI9486 supports various MCU interfaces, as shown below.

  • 4-line serial interface
4-line serial interface
  • 3-line serial interface 
3-line serial interface
  • 16-bit parallel bus interface
16-bit parallel bus interface

Let’s have a look at the features of the ILI9486 chip in the next section. 

Features of the ILI9486 module

Here are the features of the Arduino-compatible ILI9486 LCD driver:

  • Display resolution – 320 x 480
  • On-chip display RAM of 345,600 bytes
  • Multiple interface support
    • 8080-series parallel interface
    • 16-bits, 18-bits RGB interface
    • 3-line / 4-line serial
  • Display mode
    • Full color
    • Reduce color mode (saves power)
  • Low Power consumption architecture
  • Wide operating temperature range
  • On chip functions
    • Timing generator
    • DC/DC converter
    • RGB Gamma correction etc

Pin Details Of The LCD Driver module – ILI9486

This is a picture of the LCD shield featuring the ILI9486 as its LCD controller.

The shield is specifically designed to be mounted directly onto the Arduino UNO, which not only saves time in setting up the project but also prevents any potential connection errors.

Pin Details Of The LCD Driver module - ILI9486

I have summarised the pin description of the ILI9486 Display module below:

Pin NamePin Description
LCD_RSTLCD bus reset signal, low-level reset
LCD_CSLCD bus chip select signal, low level enable
LCD_RSLCD bus command/data selection signal
LCD_WRLCD bus write signal
LCD_RDLCD bus read signal
GNDPower ground
5V5V power input
3V33.3V power input, this pin can be disconnected
LCD_D0LCD 8-bit data Bit0
LCD_D1LCD 8-bit data Bit1
LCD_D2LCD 8-bit data Bit2
LCD_D3LCD 8-bit data Bit3
LCD_D4LCD 8-bit data Bit4
LCD_D5LCD 8-bit data Bit5
LCD_D6LCD 8-bit data Bit6
LCD_D7LCD 8-bit data Bit7
SD_SSSD card SPI bus chip select signal, low level enable
SD_DISD card SPI bus MOSI signal
SD_DOSD card SPI bus MISO signal
SD_SCKSD card SPI bus clock signal

Applications of ILI9486 LCD Module

Industrial control panels – The high resolution and color depth of the ILI9486 make it a great option for displaying important data in industrial control panels, such as temperature and pressure readings, flow rates, and other system parameters.

Gaming devices – The fast response time and color depth of the ILI9486 make it a great choice for displays in gaming devices, such as handheld consoles and portable gaming systems.

Medical equipment – The high resolution and color depth of the ILI9486 are well-suited to medical devices such as patient monitors and imaging systems, which require clear, accurate visual information to make critical decisions.

Automotive displays – You can find ILI9486 used for in-dash displays in automobiles, providing drivers with information on speed, fuel levels, and other important metrics.

Smart home devices – The ILI9486 can be used in smart home devices such as thermostats and security systems, providing users with a clear and intuitive display of relevant information.

Wearables – The small form factor of the ILI9486 makes it a good option for use in wearable devices.

Step-By-Step Instructions To Connect The ILI9486 LCD Module With Arduino UNO

In this section, we will build a project using Arduino UNO and an LCD shield based on ILI9486. The connections are easy to take significantly less time to complete.

Let’s get started with the hardware connections!

How To Connect The ILI9486 LCD Module To The Arduino UNO?

Below is the step-by-step connection guide to complete the Arduino and the LCD Module ILI9486. 

Step 1: Start with the Module

Start with the Module

There are no wire connections required. You have to mount the LCD shield on to the Arduino carefully. 

Step 2: Hold the Arduino UNO and place the LCD shield on it

Hold the Arduino UNO and place the LCD shield on it

Once you mount the LCD shield on the Arduino UNO, firmly press it down. You can now test the setup with the example code in the next section. 

Step 3: Final connection

Final connection

Congratulations. You have completed the connections successfully.

Arduino Code Example For The ILI9486 LCD Project

In this section, you can find the complete Arduino sketch to test the LCD functionality. 

The complete Arduino Code For The ILI9486 Arduino Project Example

#include "Adafruit_GFX.h"
#include "MCUFRIEND_kbv.h"

#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

MCUFRIEND_kbv tft;

void setup() {
  // Reading TFT ID:
  uint16_t ID = tft.readID();
  Serial.begin(9600);
  Serial.println(ID);
  //Initializing TFT display:
  tft.begin(ID);
}

void loop() {
  // Fill TFT Screen with a color:
  tft.fillScreen(BLACK);
  delay(500);

  // Fill a rectangle:
  tft.fillRect(11, 11, 298, 48, RED);
  delay(500);

  //Draw a rectangle:
  tft.drawRect(10, 10, 300, 50, YELLOW);
  delay(500);

  //Set cursor:
  tft.setCursor(80, 25);

  //Set text color:
  tft.setTextColor(WHITE);

  //Set text size:
  tft.setTextSize(2);

  //Print text to TFT display:
  tft.println("EEWORLDONLINE");
  delay(2000);

  //Draw Lines
  for (int i = 65; i < 480; i += 7) {
    tft.drawLine(0, 240, 100, i, CYAN);
    delay(100);
  }

  //Draw Circles
  for (int i = 60; i > 5; i -= 5) {
    tft.drawCircle(210, 140, i, GREEN);
    delay(30);
  }

  //Draw rectangles
  for (int i = 100; i > 30; i -= 10) {
    tft.drawRect(150, 220, i, i, YELLOW);
    delay(30);
  }

  //Draw Triangles
  for (int i = 10; i < 50; i += 5) {
    tft.drawTriangle(
      200, 360 + i,
      150 + i, 460 - i,
      250 - i, 460 - i,
      RED
    );
  }
  delay(2000);

  tft.fillScreen(WHITE);
  tft.fillRect(10, 10, 300, 60, YELLOW);
  tft.setCursor(40, 30);
  tft.setTextSize(2);
  tft.setTextColor(MAGENTA);
  tft.println("Thanks for watching !");

  tft.fillRect(7, 100, 300, 70, YELLOW);
  tft.setCursor(10, 100);
  tft.setTextSize(2);
  tft.setTextColor(RED);
  tft.println("Stay connected with us");
  tft.println(" @ EngineersGarage.com");
  delay(5000);
}

Let’s walk through the Arduino code above for the ILI9486 module. I find it easy to understand the code when I break it into smaller blocks (functions). 

This Arduino code initializes the display, fills the screen with colours, draws multiple shapes and more.

#include "Adafruit_GFX.h"
#include "MCUFRIEND_kbv.h"

I am using the above libraries to control the TFT display. The libraries Adafruit_GFX and MCUFRIEND_kbv are two helpful libraries among many.

#define BLACK   0x0000
#define BLUE    0x001F
#define RED     0xF800
#define GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

We define the colors using RGB format. In this code, we are using two bytes to represent the colors.

RGB -> RRRRR – GGGGGG – BBBBB (16-bit information, which is a 2-byte data)

void setup() {
  // Reading TFT ID:
  uint16_t ID = tft.readID();
  Serial.begin(9600);
  Serial.println(ID);
  //Initializing TFT display:
  tft.begin(ID);
}

This is the setup() function that runs only once when you power the Arduino or reset it.

We read the ID of the TFT display.It also initializes the serial communication, prints the ID to the serial monitor.

The function also initializes the display using the tft.begin(ID) function. In the next line, we will jump to the loop() function.

  tft.fillScreen(BLACK);
  delay(500);

The tft.fillScreen(BLACK) fills the entire screen with black color. Later, we wait fro 500 ms.

  // Fill a rectangle:
  tft.fillRect(11, 11, 298, 48, RED);
  delay(500);

The function tft.fillRect() fills a rectangle with red color in the specified location. Later, we wait for 500 ms again.

  //Draw a rectangle:
  tft.drawRect(10, 10, 300, 50, YELLOW);
  delay(500);

The function tft.drawRect() draws a rectangle with a yellow in the specified location and waits for 500 ms.

  //Set cursor:
  tft.setCursor(80, 25);

  //Set text color:
  tft.setTextColor(WHITE);

  //Set text size:
  tft.setTextSize(2);

  //Print text to TFT display:
  tft.println("EEWORLDONLINE");
  delay(2000);

This code snippet sets the cursor position, text color, and text size and prints a string of text on display. We wait for 2000 ms.

  //Draw Lines
  for (int i = 65; i < 480; i += 7) {
    tft.drawLine(0, 240, 100, i, CYAN);
    delay(100);
  }

This code draws multiple lines with a cyan color at different angles. We are then waiting for 100 ms between each line.

I encourage you to tinker with the code and start building your own custom text and drawings.

FAQs About The TFT Display Module ILI9486 Module And The Arduino UNO Projects

I have included a list of the most frequently asked questions about projects built using Arduino and the TFT module – ILI9486.

If you have more questions, please post them in the comments section.

I will be happy to answer them.

1. What is the maximum resolution that the ILI9486 can support?

The ILI9486 is a display controller designed to drive LCD screens with a maximum resolution of 320×480 pixels.

This means the ILI9486 can support a wide range of displays requiring high-resolution graphics.

Hence, it is a great option for designers and engineers who must create high-quality visuals for their projects.

2. Is the ILI9486 compatible with Arduino?

Yes, the ILI9486 is highly compatible with various microcontrollers, including Arduino boards such as UNO and Mega.

You can easily integrate the ILI9486 into your future projects without worrying about compatibility issues or complex coding requirements.

3. Can I use the ILI9486 for creating digital picture frames?

Absolutely! The ILI9486 is an excellent choice for creating digital picture frames. Its high resolution and color support make it a great option for displaying high-quality images and graphics. 

Also, the ILI9486’s compatibility with Arduino allows developers to create custom interfaces for their digital picture frames easily.

There are several famous libraries that you can use. 

4. Can the ILI9486 be used for gaming consoles?

Yes, the ILI9486 is a great option for creating gaming consoles due to its high resolution and fast refresh rates.

The ILI9486’s RGB interface enables high-speed data transfer, essential for creating smooth and responsive gameplay experiences.

5. How much voltage does the ILI9486 require?

The ILI9486 typically requires a voltage of 3.7 to operate correctly. 

It’s important to refer to the manufacturer’s display datasheet to understand the voltage requirements of the LCD module.

The ILI9486 is an LCD controller integrated into display modules by various LCD suppliers.

Keep in mind that the specifications may vary among the different suppliers.

6. How much current does the ILI9486 consume?

The ILI9486 typically consumes between 10 mA and 20 mA of current when in use, depending on the specific application and usage requirements.

I recommend you to refer to the actual use case to determine the exact current consumption for your particular project.

Conclusion

I hope I have provided you with the good understanding of the ILI9486 LCD controller and its features.

I have included a working code example, connection diagrams, and a step-by-step guide to help you start with the ILI9486 controller. 

These resources should make it easier for you to start working with the controller and developing your own display module projects.

I will be excited to hear what you build next! Please share it in the comments section. 

Also, don’t forget to share the article with fellow Arduino enthusiasts and friends.

Happy tinkering, and keep learning!