Arduino spi display

Arduino spi display DEFAULT

Serial SPI Arduino 5"TFT LCD Touch Shield RA8875 for Mega/Due/Uno


Spice up your Arduino project with a beautiful large touchscreen display shield with built in microSD card connection. This TFT display is big (5" diagonal) bright (18 white-LED backlight) and colorfu 800x480 pixels with individual pixel control. As a bonus, this display has a optional resistive touch panel attached on screen by default.

The shield is fully assembled, tested and ready to go. No wiring, no soldering! Simply plug it in and load up our library - you'll have it running in under 10 minutes! Works best with any classic Arduino (UNO/Due/Mega 2560). 
This display shield has a controller built into it with RAM buffering, so that almost no work is done by the microcontroller. You can connect more sensors, buttons and LEDs.

Of course, we wouldn't just leave you with a datasheet and a "good luck!" - we've written a full open source graphics library at the bottom of this page that can draw pixels, lines, rectangles, circles and text. We also have a touch screen library that detects x,y and z (pressure) and example code to demonstrate all of it. The code is written for Arduino but can be easily ported to your favorite microcontroller!

For people who want the same screen but not in a shield, check out our 5" TFT breakout.

What's included in the package ?

NumberStandard Accessory NameQuantity
15 inch TFT LCD Display with RA8875 Controller Board1
2Arduino Shield1

*The default power supply is 5V and the default interface is 4-wire serial interface. 

Compatible with following Arduino Boards

Board NameMCUI/O
Arduino MEGA2560ATMEGA256054
Arduino MEGA1280ATMEGA128054
Arduino DueAT91SAM3X8EA54
Arduino UnoATMEGA32814


If you've had a lot of Arduino DUEs go through your hands (or if you are just unlucky), chances are you’ve come across at least one that does not start-up properly.The symptom is simple: you power up the Arduino but it doesn’t appear to “boot”. Your code simply doesn't start running.You might have noticed that resetting the board (by pressing the reset button) causes the board to start-up normally.The fix is simple,here is the solution.

Datasheet for Display Module

Datasheet and Schematic for Arduino Shield

Datasheet for Resistive Touch Panel

Tutorial - Arduino Due (MEGA 2560,Uno)Libraries,Examples


3.5inch 480x320 MCU SPI Serial TFT LCD Module Display


It is the cutest, little display for the Raspberry Pi. It features a 3.5" display with 480x320, support 65K color display.



  • 3.5-inch color screen,support 65K color display,display rich colors
  • 480X320 resolution, optional touch function
  • Using the SPI serial bus, it only takes a few IOs to illuminate the display
  • Easy to expand the experiment with SD card slot
  • Provide a rich sample program
  • Military-grade process standards, long-term stable work
  • Provide underlying driver technical support


  • Display Color: RGB 65K color
  • Screen Size: 3.5(inch)
  • Type: TFT
  • Driver IC: ILI9488
  • Resolution: 480*320 (Pixel)
  • Module Interface: 4-wire SPI interface
  • Active Area (AA area): 48.96x73.44(mm)
  • Module PCB Size: 56.34x98(mm)
  • Operating Temperature: -20℃~60℃
  • Storage Temperature: -30℃~70℃
  • VCC power voltage: 3.3V~5V
  • Logic IO port voltage: 3.3V(TTL)
  • Power Consumption: TBD
  • Rough Weight: 45 (g)

Interface Definition

3.5inch SPI Module ILI9488 1.png650px

How to use with Arduino

1: Run Arduino Demo in SPI model

When we directly connected the SPI display module without the on-board level conversion module to the Arduino, we found that it could not run at all. This is because the SPI module's pin can only input a 3.3V high level, while the Arduino output has a high level of 5V. To run successfully, there are two Method: short circuit method and external level conversion module method. The short-circuit method has the advantages of simple operation, short wiring, and no need for external devices. The disadvantage is that the module generates a large amount of heat during operation.Will affect the life of the module. The external level conversion module method is a normal operation, and the advantage is that the module generatesless heat and runs stably during operation, and the disadvantage is that the operation is slightly complicated. (An external level shifting module is required) to increase the cost (additional level conversion module is required). In summary, it is recommended to use the external level shifting module method.

Step 1: Short-Circuit Method
The short-circuit method is to short the J1 component position (shown below) with solder on the back of the module.After shorting, the runtime module VCC The pin must be connected to a 5V power supply (not connected to 3.3V). 3.5inch SPI Module ILI9488 2.png

Step 2: External Level Conversion Module Method
The so-called external level conversion module method is to connect the Arduino and the display module through an external level conversion module, so that The 5V high level of the Arduino output is converted to 3.3V by the level conversion module and then input to the display module. As shown below: 3.5inch SPI Module ILI9488 3.png

2: First download the sample code. Then copy the libraries that the examples depend on to the libraries folder of the Arduino project file directory.

3.5inch SPI Module ILI9488 4.png

3: Select the example you want to test, open it and click Tools button to select the board model and port number, as shown below:

3.5inch SPI Module ILI9488 5.png

4: Connect the pins with the Arduino pins with Dupont wires according to the pin definitions in the program. (The example is a short-circuit method)

3.5inch SPI Module ILI9488 6.png

5: Click the Upload button to compile and download. When “Done Uploading” is displayed, the program had been successfully downloaded to the development board, as shown below:

3.5inch SPI Module ILI9488 7.png

6: If the module can display normally, the program runs successfully:

3.5inch SPI Module ILI9488 8.png

  1. Popular anime hashtags
  2. Sentence with bump
  3. Thriller action novels

The TFT library is included with Arduino IDE 1.0.5 and later.

This library enables an Arduino board to communicate with the Arduino TFT LCD screen. It simplifies the process for drawing shapes, lines, images, and text to the screen.

The Arduino TFT library extends the Adafruit GFX, and Adafruit ST7735 libraries that it is based on. The GFX library is responsible for the drawing routines, while the ST7735 library is specific to the screen on the Arduino TFT. The Arduino specific additions were designed to work as similarly to the Processing API as possible.

Onboard the screen is a SD card slot, which can be used through the SD library.

The TFT library relies on the SPI library for communication with the screen and SD card, and needs to be included in all sketches.

To use this library

Using the library

The screen can be configured for use in two ways. One is to use an Arduino's hardware SPI interface. The other is to declare all the pins manually. There is no difference in the functionality of the screen between the two methods, but using hardware SPI is significantly faster.

If you plan on using the SD card on the TFT module, you must use hardware SPI. All examples in the library are written for hardware SPI use.

If using hardware SPI with the Uno, you only need to declare the CS, DC, and RESET pins, as MOSI (pin 11) and SCLK (pin 13) are already defined.

#define CS   10
#define DC   9
#define RESET  8

TFT myScreen = TFT(CS, DC, RESET);

[Get Code]

To use hardware SPI with the Leonardo, you declare the pins like so :

#define CS   7
#define DC   0
#define RESET  1

TFT myScreen = TFT(CS, DC, RESET);

[Get Code]

When not using hardware SPI, you can use any available pins, but you must declare the MOSI and SCLK pins in addition to CD, DC, and RESET.

#define SCLK 4
#define MOSI 5
#define CS   6
#define DC   7
#define RESET 8


[Get Code]

Using the Arduino Esplora and the TFT library

As the Arduino Esplora has a socket designed for the TFT, and the pins for using the screen are fixed, an Esplora only object is created when targeting sketches for that board. You can reference the screen attached to an Esplora through .

Similarities to Processing

Processing is an open source software environment used by designers, artists, and students. The main output of Processing is a graphic window on a computer or browser. The Arduino TFT library has made the calls for drawing primitives and text to the screen as "Processing-like" as possible to ensure a smooth transition between the two environments.


There are two groups of examples for the TFT. There are examples specific to the Arduino Esplora, and examples that are designed for boards like the Uno or Leonardo. It should be easy to translate from one to the other once you've gotten a handle on the library and its functionality.

  • TFT Bitmap Logo: Read an image file from a micro-SD card and draw it at random locations.
  • TFT Color Picker: With three sensors, change the color of the TFT screen.
  • TFT Display Text: Read the value of a sensor and print it on the screen.
  • TFT Etch a Sketch: An Arduino version of the classic Etch-a-Sketch.
  • TFT Graph: Graph the values from a variable resistor to the TFT.
  • TFT Pong: An Arduino implementation of the classic game.
LCD DISPLAY 128x64 ST7920 GRAPHIC SPI - Arduino tutorial #16

Install Adafruit GFX and Adafruit ILI9341 device libraries.

Adafruit ILI9341 library is best suitable for the ILI9488 device.

Adafruit ILI9341 library is modified for adopting ILI9488 LCD controller.

Only, the Height and Width parameters at Adafruit_ILI9341.h file is modified to

#define ILI9341_TFTWIDTH 320

#define ILI9341_TFTHEIGHT 480

And at the Adafruit_ILI9341.cpp file, at the function Adafruit_ILI9341::begin(void), the following lines are modified for adapting ILI9488 device (320x480 pixels).

writecommand(ILI9341_DFUNCTR); // Display Function Control




Included DHT library offers the read interface for the sensor.

Arduino reads the temperature and humidity values at 2 seconds interval.

The temperature is in Celsius format, which is converted into Fahrenheit, Kelvin and Rankine format by the software.

A two column five row, multi colored table is drawn by using Arduino GFX lib, for displaying the temperature and humidity.

Converted four formats of temperature are send to the serial port and also displayed on the TFT LCD.

//Experiment of 3.5 Inch LCD (320x480), ILI9488 SPI Interface driver
//And experiment of DHT22 digital temperature / humidity sensor //Adafruit ILI9341 library is modified for ILI9488 (320x480)

// DHT22 Data line connected to Arduino digital IO 2

// LCD MOSI to Arduino digital IO D11 // LCD SCLK to Arduino digital IO D13 // LCD CS to Arduino digital IO D10 // LCD RS / DS to Arduino digital IO D9

// Name:- M.Pugazhendi // Date:- 01stSep2016 // Version:- V0.1 // e-mail:- [email protected]

//Include Libraries #include <DHT.h> #include "SPI.h" #include "Adafruit_GFX.h" #include "Adafruit_ILI9341.h"

//Constants #define SERIAL_DEBUG

// DHT22 #define DHTPIN 2 #define DHTTYPE DHT22

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

// Initialize LCD // 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);

// Initialize DHT sensor for normal 16mhz Arduino DHT dht(DHTPIN, DHTTYPE);

//Variables float hum; //Stores humidity value float temp; //Stores temperature value float converted = 0.00;

//Arduino setup void setup() { #ifdef SERIAL_DEBUG Serial.begin(9600); Serial.println("ILI9341 Test!"); Serial.println("DHT22 temperature / humidity sensor Test"); #endif //Initialize TFT LCD tft.begin();

//Initialize the DHT sensor dht.begin(); #ifdef SERIAL_DEBUG // 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); #endif

//Rotate the screen to right direction tft.setRotation(1);

//Print the headers printHeader(); }

//Main loop void loop(void) {

//Read data and store it to variables hum and temp hum = dht.readHumidity(); temp= dht.readTemperature(); printTemperatureHumidity();

//Delay 2 Seconds delay(2000); }

//Print headers unsigned long printHeader(void ) { tft.fillRect(0,0,240, 64,ILI9341_GREEN); tft.fillRect(0,64,240, 64,ILI9341_RED); tft.fillRect(0,128,240, 64,ILI9341_CYAN); tft.fillRect(0,192,240, 64,ILI9341_YELLOW); tft.fillRect(0,256,240, 64,ILI9341_ORANGE);

unsigned long start = micros(); tft.setTextColor(ILI9341_BLACK); tft.setTextSize(3); // tft.setCursor(50,0+20); tft.print("CELCIUS");

// tft.setCursor(50,64+20); tft.print("FAHRENHEIT"); // tft.setCursor(50,128+20); tft.print("KELVIN");

// tft.setCursor(50,192+20); tft.print("RANKIN");

// tft.setCursor(50,256+20); tft.print("HUMIDITY"); return micros() - start; }

//Print temperature and humidity unsigned long printTemperatureHumidity() { tft.fillRect(241,0,240, 64,ILI9341_CYAN); tft.fillRect(241,64,240, 64,ILI9341_YELLOW); tft.fillRect(241,128,240, 64,ILI9341_ORANGE); tft.fillRect(241,192,240, 64,ILI9341_GREEN); tft.fillRect(241,256,240, 64,ILI9341_RED); //tft.fillScreen(ILI9341_BLUE); unsigned long start = micros(); tft.setTextColor(ILI9341_BLACK); tft.setTextSize(4);

#ifdef SERIAL_DEBUG Serial.print("Celsius = "); Serial.print(temp); //Print degree symbol Serial.write(176); Serial.println("C"); #endif tft.setCursor(250,0+20); tft.print(temp); tft.print(" "); tft.print((char)247); tft.println("C");

//Fahrenheit //T(°F) = T(°C) × 9/5 + 32 converted = ( temp * 1.8 ) + 32; #ifdef SERIAL_DEBUG Serial.print("Fahrenheit = "); Serial.print(converted); //Print degree symbol Serial.write(176); Serial.println("F"); #endif tft.setCursor(250,64+20); tft.print(converted); tft.print(" "); tft.print((char)247); tft.println("F");

//Kelvin //T(K) = T(°C) + 273.15 converted = temp + 273.15; #ifdef SERIAL_DEBUG Serial.print("Kelvin = "); Serial.print(converted); Serial.println(" K"); #endif tft.setCursor(250,128+20); tft.print(converted); tft.print(" "); tft.println("K");

//Rankine //T(°R) = (T(°C) + 273.15) × 9/5 converted = temp + 273.15; converted = (converted * 1.8); #ifdef SERIAL_DEBUG Serial.print("Rankin = "); Serial.print(converted); //Print degree symbol Serial.write(176); Serial.println("R"); #endif tft.setCursor(250,192+20); tft.print(converted); tft.print(" "); tft.print((char)247); tft.println("R");

//Humidity #ifdef SERIAL_DEBUG Serial.print("Humidity ="); Serial.println(hum); #endif tft.setCursor(250,256+20); tft.print(hum); tft.print(" "); tft.println("%"); return micros() - start; }


Spi display arduino

In this guide we’re going to show you how you can use the 1.8 TFT display with the Arduino. You’ll learn how to wire the display, write text, draw shapes and display images on the screen.

Introducing the 1.8 TFT Display

The 1.8 TFT is a colorful display with 128 x 160 color pixels. The display can load images from an SD card – it has an SD card slot at the back. The following figure shows the screen front and back view.

This module uses SPI communication – see the wiring below . To control the display we’ll use the TFT library, which is already included with Arduino IDE 1.0.5 and later.

Where to buy?

You can get the 1.8 TFT display for approximately $3 – check prices on Maker Advisor.

You can use the preceding links or go directly to to find all the parts for your projects at the best price!

Pin wiring

The table below shows the 1.8 TFT wiring to Arduino UNO.

1.8 TFT DisplayWiring to Arduino Uno
LED3.3 V
SCK 13
A0 or DC9
CS 10

Note: different Arduino boards have different SPI pins. If you’re using another Arduino board, check the Arduino official documentation.

Initializing the display

The TFT display communicates with the Arduino via SPI communication, so you need to include the SPI library on your code. We also use the TFT library to write and draw on the display.

#include <TFT.h> #include <SPI.h>

Then, you need to define the CS, A0 (or DC) and RST pins:

#define cs 10#define dc 9#define rst 8

Create an instance of the library called TFTscreen:

TFT TFTscreen = TFT(cs, dc, rst);

Finally, in the setup(), you need to initialize the library:


Display text

To write text on the display, you can customize the screen background color, font size and color.

To set the background color, use:

TFTscreen.background(r, g, b);

In which, rg and b are the RGB values for a given color. To choose font color:

TFTscreen.stroke(r, g, b);

To set the font size:


You can increase or decrease the number given as argument, to increase or decrease font size.

Finally, to draw text on the display you use the following line:

TFTscreen.text("Hello, World!", x, y);

In which “Hello, World!” is the text you want to display and the (x, y) coordinate is the location where you want to start display text on the screen.


The following example displays “Hello, World!” in the middle of the screen and changes the font color every 200 miliseconds.

Copy the following code to your Arduino IDE and upload it to your Arduino board.

View raw code

Here’s your “Hello, World!” text on the 1.8 TFT display.

Display shapes

The TFT library provides useful functions to draw shapes on the display:

  • TFTscreen.point(x, y) – display a point at the (x, y) coordinate
  • TFTscreen.line(xStart, yStart, xEnd, yEnd) – draws a line that starts at (xStart, yStart) and ends at (xEnd, yEnd)
  • TFTscreen.rect(xStart, yStart, width, height) – draws a rectangle with the top left corner at (xStart, yStart) with the defined width and height
  •, y, radius) – draws a circle with center at (x, y) with the specified radius


The following example displays several shapes. Every time the code goes through the loop, the shapes change color.

Copy the following code to your Arduino IDE and upload it to your Arduino board.

View raw code

Here’s the shapes on the display: 

Display images

The 1.8 TFT display can load images from the SD card. To read from the SD card you use the SD library, already included in the Arduino IDE software. Follow the next steps to display an image on the display:

1) Solder header pins for the SD card. There are four pins opposite to the display pins, as shown in figure below.

2) The display can load images bigger or smaller than the display size (160 x 128 px), but for better results, edit your image size to 160 x 128 px.

3) The image should be in .bmp format. To do that, you can use a photo editing software and save the image as .bmp format.

4) Copy the image to the SD card and insert it on the SD card slot at the back of the display.

5) Wire the SD card pins to the Arduino by following the table below:

SD card on TFT displayWiring to Arduino Uno

Both the display and the SD card work with SPI communication, so you’ll have pins on the Arduino with two connections.

6) In the Arduino IDE go to File > Examples > TFT > Arduino > TFTBitmaLogo.

7) Edit the code, so that it searches for your image. Replace the “arduino.bmp” with the name of your image:

// now that the SD card can be access, try to load the image file logo = TFTscreen.loadImage("arduino.bmp");

8) Upload the code to your Arduino.

Note: some people find issues with this display when trying to read from the SD card. We don’t know why that happens. In fact, we tested a couple of times and it worked well, and then, when we were about to record to show you the final result, the display didn’t recognized the SD card anymore – we’re not sure if it’s a problem with the SD card holder that doesn’t establish a proper connection with the SD card. However, we are sure these instructions work, because we’ve tested them.

Wrapping up

In this guide we’ve shown you how to use the 1.8 TFT display with the Arduino: display text, draw shapes and display images. You can easily add a nice visual interface to your projects using this display.

Do you have any projects with the 1.8 TFT display? Let us know in the comments section below.

If you liked this post, you may also find useful:

 Thanks for reading.

LCD DISPLAY 128x64 ST7920 GRAPHIC SPI - Arduino tutorial #16

I'm just Cyril. Do you know what to ask about. - The guy propped his chin with his fist, there were still a couple of abrasions on his lips after yesterday's "fight", if you could call it that.

Similar news:

Okay. - Finally I said. - Let's say you're right. But Anthony was there. The fact that he participated in the attacks of monsters does not mean that he is the main villain.

1730 1731 1732 1733 1734