IOT

How to Interface the TFT LCD with Arduino Uno?

In most the Arduino projects, we would be extremely delighted to have a display through which we can monitor the vitals of our project. A TFT (Thin Film Transistor) type driver is the most popular form of LCD panel driver currently available. Through the active switch, it achieves independent and exact control of each pixel, allowing it to generate finer visual effects than the preceding passive driver (commonly known as pseudocolor). As a result, TFT has been used to power most LCD screens, LCD televisions, and certainly mobile phones.

In this blog, we are going to discuss the basics of TFT LCD Display, and how to interface the TFT LCD with Arduino Uno in detail.

What Does Thin-Film Transistor Liquid Crystal Display (TFT LCD) Mean?

TFT LCDs (thin-film transistor liquid crystal displays) are a form of liquid crystal display (LCD) that uses thin-film transistor technology to increase features like contrast and addressability. A single transistor is utilized to drive each individual pixel in TFT technology, providing for faster response times.

TFT (Thin Film Transistor) is a thin film field effect transistor that can “actively” control each individual pixel on the screen, resulting in a significant reduction in response time. TFTs have a reasonably fast response time of about 80 milliseconds and a large viewing angle of about 130 degrees, which is why they are mostly employed in high-end devices. This device has the ability to display screen information at a high rate, with a high brightness, and with a high contrast. TFT stands for thin film transistor, and it is a liquid crystal display that is operated by an “active matrix” approach. To manufacture transistor electrodes, thin film technology is used, and the scanning method is used to “actively pull” to control the opening of any display point. When a light source is irradiated, it emits light.

To make transistor electrodes, thin film technology is used, and the scanning method is used to “actively pull” to control the opening of any display point. When a light source is irradiated, the light first passes through the lower polarizing plate and is then transmitted by the liquid crystal molecules, achieving the display’s goal of shielding and transmitting light.

Basic Construction of a TFT LCD

Thin-film transistor liquid crystal display technology employs “field-effect” transistors, which are constructed by layering thin films on a glass substrate, as the name implies. Microprocessors are frequently made using this method. 

The TFT in the LCD controls individual pixels in the display by controlling the polarization of the crystal material by setting the level of the electric field across the three liquid crystal capacitors (one for each subpixel of red, green, and blue) in the pixel. The amount of light that reaches the color filter from the backlight is determined by the amount of polarization in the crystal. TFT is also known as active-matrix LCD technology because of its ability to manipulate each pixel directly and quickly. The following are the different layers of a TFT LCD

 1. Polarization layer

 2. Thin Film Transistor

 3. Liquid Crystal

 4. RGB Color filter

TFT LCD interfacing with Arduino Uno

 Components You will need to work with this module:

Hardware Required:

Software Required:

Interfacing Diagram For TFT LCD

Arduino with 2.4 inch tft display

Arduino Uno Code for 2.8 inch TFT LCD

/***************************************************

  This is our GFX example for the Adafruit ILI9341 Breakout and Shield

  —-> http://www.adafruit.com/products/1651

  These displays use SPI to communicate, 4 or 5 pins are required to

  interface (RST is optional)

  Adafruit invests time and resources providing this open source code,

  please support Adafruit and open-source hardware by purchasing

  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.

  MIT license, all text above must be included in any redistribution

 ****************************************************/



#include “SPI.h”
#include “Adafruit_GFX.h”
#include “Adafruit_ILI9341.h”

// For the Adafruit shield, these are the default.
#define TFT_DC 9
#define TFT_CS 10

// Use hardware SPI (on Uno, #13, #12, #11) and the above for CS/DC
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);
// If using the breakout, change pins as desired
//Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_MOSI, TFT_CLK, TFT_RST, TFT_MISO);

void setup() {
Serial.begin(9600);
Serial.println(“ILI9341 Test!”);

tft.begin();

// read diagnostics (optional but can help debug problems)
uint8_t x = tft.readcommand8(ILI9341_RDMODE);
Serial.print(“Display Power Mode: 0x”); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDMADCTL);
Serial.print(“MADCTL Mode: 0x”); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDPIXFMT);
Serial.print(“Pixel Format: 0x”); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDIMGFMT);
Serial.print(“Image Format: 0x”); Serial.println(x, HEX);
x = tft.readcommand8(ILI9341_RDSELFDIAG);
Serial.print(“Self Diagnostic: 0x”); Serial.println(x, HEX);

Serial.println(F(“Benchmark Time (microseconds)”));
delay(10);
Serial.print(F(“Screen fill “));
Serial.println(testFillScreen());
delay(500);

Serial.print(F(“Text “));
Serial.println(testText());
delay(3000);

Serial.print(F(“Lines “));
Serial.println(testLines(ILI9341_CYAN));
delay(500);

Serial.print(F(“Horiz/Vert Lines “));
Serial.println(testFastLines(ILI9341_RED, ILI9341_BLUE));
delay(500);

Serial.print(F(“Rectangles (outline) “));
Serial.println(testRects(ILI9341_GREEN));
delay(500);

Serial.print(F(“Rectangles (filled) “));
Serial.println(testFilledRects(ILI9341_YELLOW, ILI9341_MAGENTA));
delay(500);

Serial.print(F(“Circles (filled) “));
Serial.println(testFilledCircles(10, ILI9341_MAGENTA));

Serial.print(F(“Circles (outline) “));
Serial.println(testCircles(10, ILI9341_WHITE));
delay(500);

Serial.print(F(“Triangles (outline) “));
Serial.println(testTriangles());
delay(500);

Serial.print(F(“Triangles (filled) “));
Serial.println(testFilledTriangles());
delay(500);

Serial.print(F(“Rounded rects (outline) “));
Serial.println(testRoundRects());
delay(500);

Serial.print(F(“Rounded rects (filled) “));
Serial.println(testFilledRoundRects());
delay(500);

Serial.println(F(“Done!”));

}


void loop(void) {
for(uint8_t rotation=0; rotation<4; rotation++) {
tft.setRotation(rotation);
testText();
delay(1000);
}
}

unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(ILI9341_BLACK);
yield();
tft.fillScreen(ILI9341_RED);
yield();
tft.fillScreen(ILI9341_GREEN);
yield();
tft.fillScreen(ILI9341_BLUE);
yield();
tft.fillScreen(ILI9341_BLACK);
yield();
return micros() – start;
}

unsigned long testText() {
tft.fillScreen(ILI9341_BLACK);
unsigned long start = micros();
tft.setCursor(0, 0);
tft.setTextColor(ILI9341_WHITE); tft.setTextSize(1);
tft.println(“Hello World!”);
tft.setTextColor(ILI9341_YELLOW); tft.setTextSize(2);
tft.println(1234.56);
tft.setTextColor(ILI9341_RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(ILI9341_GREEN);
tft.setTextSize(5);
tft.println(“Groop”);
tft.setTextSize(2);
tft.println(“I implore thee,”);
tft.setTextSize(1);
tft.println(“my foonting turlingdromes.”);
tft.println(“And hooptiously drangle me”);
tft.println(“with crinkly bindlewurdles,”);
tft.println(“Or I will rend thee”);
tft.println(“in the gobberwarts”);
tft.println(“with my blurglecruncheon,”);
tft.println(“see if I don’t!”);
return micros() – start;
}

unsigned long testLines(uint16_t color) {
unsigned long start, t;
int x1, y1, x2, y2,
w = tft.width(),
h = tft.height();

tft.fillScreen(ILI9341_BLACK);
yield();

x1 = y1 = 0;
y2 = h – 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w – 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t = micros() – start; // fillScreen doesn’t count against timing

yield();
tft.fillScreen(ILI9341_BLACK);
yield();

x1 = w – 1;
y1 = 0;
y2 = h – 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() – start;

yield();
tft.fillScreen(ILI9341_BLACK);
yield();

x1 = 0;
y1 = h – 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w – 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t += micros() – start;

yield();
tft.fillScreen(ILI9341_BLACK);
yield();

x1 = w – 1;
y1 = h – 1;
y2 = 0;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = 0;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);

yield();
return micros() – start;
}

unsigned long testFastLines(uint16_t color1, uint16_t color2) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height();

tft.fillScreen(ILI9341_BLACK);
start = micros();
for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);

return micros() – start;
}

unsigned long testRects(uint16_t color) {
unsigned long start;
int n, i, i2,
cx = tft.width() / 2,
cy = tft.height() / 2;

tft.fillScreen(ILI9341_BLACK);
n = min(tft.width(), tft.height());
start = micros();
for(i=2; i<n; i+=6) {
i2 = i / 2;
tft.drawRect(cx-i2, cy-i2, i, i, color);
}

return micros() – start;
}

unsigned long testFilledRects(uint16_t color1, uint16_t color2) {
unsigned long start, t = 0;
int n, i, i2,
cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;

tft.fillScreen(ILI9341_BLACK);
n = min(tft.width(), tft.height());
for(i=n; i>0; i-=6) {
i2 = i / 2;
start = micros();
tft.fillRect(cx-i2, cy-i2, i, i, color1);
t += micros() – start;
// Outlines are not included in timing results
tft.drawRect(cx-i2, cy-i2, i, i, color2);
yield();
}

return t;
}

unsigned long testFilledCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;

tft.fillScreen(ILI9341_BLACK);
start = micros();
for(x=radius; x<w; x+=r2) {
for(y=radius; y<h; y+=r2) {
tft.fillCircle(x, y, radius, color);
}
}

return micros() – start;
}

unsigned long testCircles(uint8_t radius, uint16_t color) {
unsigned long start;
int x, y, r2 = radius * 2,
w = tft.width() + radius,
h = tft.height() + radius;

// Screen is not cleared for this one — this is
// intentional and does not affect the reported time.
start = micros();
for(x=0; x<w; x+=r2) {
for(y=0; y<h; y+=r2) {
tft.drawCircle(x, y, radius, color);
}
}

return micros() – start;
}

unsigned long testTriangles() {
unsigned long start;
int n, i, cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;

tft.fillScreen(ILI9341_BLACK);
n = min(cx, cy);
start = micros();
for(i=0; i<n; i+=5) {
tft.drawTriangle(
cx , cy – i, // peak
cx – i, cy + i, // bottom left
cx + i, cy + i, // bottom right
tft.color565(i, i, i));
}

return micros() – start;
}

unsigned long testFilledTriangles() {
unsigned long start, t = 0;
int i, cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;

tft.fillScreen(ILI9341_BLACK);
start = micros();
for(i=min(cx,cy); i>10; i-=5) {
start = micros();
tft.fillTriangle(cx, cy – i, cx – i, cy + i, cx + i, cy + i,
tft.color565(0, i*10, i*10));
t += micros() – start;
tft.drawTriangle(cx, cy – i, cx – i, cy + i, cx + i, cy + i,
tft.color565(i*10, i*10, 0));
yield();
}

return t;
}

unsigned long testRoundRects() {
unsigned long start;
int w, i, i2,
cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;

tft.fillScreen(ILI9341_BLACK);
w = min(tft.width(), tft.height());
start = micros();
for(i=0; i<w; i+=6) {
i2 = i / 2;
tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
}

return micros() – start;
}

unsigned long testFilledRoundRects() {
unsigned long start;
int i, i2,
cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;

tft.fillScreen(ILI9341_BLACK);
start = micros();
for(i=min(tft.width(), tft.height()); i>20; i-=6) {
i2 = i / 2;
tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
yield();
}

return micros() – start;
}


The final output of the Code   

Advantages of TFT Displays

  • Minimal energy consumption
  • Sharp visibility
  • Excellent physical design
  • Fast and accurate response time
  • Minimizes eye strain
  • Space-efficient design (can be placed anywhere in your workspace on a rotational mount so you can turn it in all directions)

Disadvantages Of TFT Displays

  • Higher price point than other displays
  • Disproportionate viewing angles
  • Restricted utility due to glass paneling (e.g., ineffective for outdoor use where glass can showcase glares from natural lighting)
  • Relies on backlighting to provide brightness rather than producing their own light, hence, they need built-in light-emitting diodes (LEDs) in their backlighting structure

TFT Applications

TFT displays are found in many applications these days, from mobile devices, appliances, medical devices, instrumentation, aircraft, and certainly computer display devices as well as TVs. The addition of the thin film transistor in LCD design vastly improved the use of LCDs in all market areas.

Conclusion:

I hope this blog helps you to understand the basics of TFT LCD Display, and how to interface the TFT LCD with Arduino Uno. We, MATHAELECTRONICS will come back with more informative blogs.

Leave a Reply

Your email address will not be published.