What is the pinout of a 2.8 inch TFT display module for Arduino?

The pinout of a 2.8 inch TFT display module for Arduino is straightforward but varies slightly depending on whether you are using the SPI or parallel interface version. The most common variant, the ILI9341-based 2.8-inch TFT with SPI interface, typically uses 8 to 10 pins for basic operation, but breakout boards often include additional pins for SD card slots or touch controllers. For the standard 240x320 resolution module, you will find a 14-pin or 16-pin header, with the pinout arranged as follows: VCC (5V or 3.3V depending on the module), GND, CS (Chip Select), RESET (or RST), DC (Data/Command), MOSI (Master Out Slave In), SCK (Serial Clock), LED (Backlight control), and MISO (Master In Slave Out, optional for read operations). Some modules also include T_IRQ, T_DO, T_DIN, and T_CS for resistive touch. If you are using a parallel 8080 interface module, the pin count jumps to 24 or more, including an 8-bit or 16-bit data bus (DB0-DB15), plus control lines like WR, RD, CS, RS, and RESET. This high-density detail is critical because wiring errors can damage the display or the Arduino. For example, the ILI9341 driver datasheet specifies that VCC must be within 2.8V to 3.3V for the logic, but many breakout boards include a voltage regulator to accept 5V from Arduino. Always check your specific module’s silkscreen or datasheet. The most reliable reference for the exact pinout of a common SPI-based 2.8-inch TFT is the product page for the 2.8 inch tft display module for arduino, which provides a labeled diagram and electrical specs. Below is a detailed breakdown of the pin functions for the SPI version, which is the most widely used with Arduino Uno or Mega.

Standard SPI Pinout for 2.8-inch TFT (ILI9341)

The SPI interface is preferred for its low pin count and compatibility with most Arduino boards. A typical module like the DM-TFT28-105 uses a 14-pin header with the following assignments. Note that some pins are shared with the SD card slot if present, so you need to use separate chip select lines.

Pin Number	Label	Function	Arduino Connection	Notes
1	VCC	Power supply (5V or 3.3V)	5V	Module has onboard regulator; check jumper
2	GND	Ground	GND	Connect to common ground
3	CS	Chip Select (active low)	Digital pin 10	Selects the display for SPI communication
4	RESET	Reset (active low)	Digital pin 9	Can be tied to Arduino reset or separate pin
5	DC	Data/Command select	Digital pin 8	High for data, low for commands
6	MOSI	Master Out Slave In	Digital pin 11 (ICSP)	SPI data from Arduino to display
7	SCK	Serial Clock	Digital pin 13 (ICSP)	SPI clock signal
8	LED	Backlight control	Digital pin 6 (PWM)	PWM for brightness; tie to 3.3V for full on
9	MISO	Master In Slave Out	Digital pin 12 (ICSP)	Optional for reading display memory
10	T_IRQ	Touch interrupt (if touch)	Digital pin 7	Active low when touch detected
11	T_DO	Touch SPI MISO	Digital pin 12 (shared)	Separate SPI for touch controller
12	T_DIN	Touch SPI MOSI	Digital pin 11 (shared)	Usually shared with display SPI
13	T_CS	Touch chip select	Digital pin 4	Separate CS for touch controller
14	T_CLK	Touch SPI clock	Digital pin 13 (shared)	Same clock as display SPI

This table reflects the pinout of the DM-TFT28-105 module, which is a robust 5V-tolerant SPI display. The LED pin is often overlooked but critical: it controls the backlight via a PWM signal. If you leave it floating, the display will be dark. Most libraries assume you connect it to a PWM-capable pin like Arduino pin 6 or 9. The RESET pin can be connected to the Arduino reset line, but using a separate digital pin gives you software control over initialization. The CS pin must be unique for each SPI device; if you also have an SD card, use a separate pin for its CS (often pin 4).

Parallel 8080 Interface Pinout (8-bit)

For applications requiring faster refresh rates, such as video or animation, the parallel interface is used. This version uses 24 pins or more. The pinout for a typical 2.8-inch TFT with 8-bit parallel interface includes DB0 through DB7 for data, plus control signals. Here is the pin mapping for an Arduino Mega, which has enough digital pins:

Pin Label	Function	Arduino Mega Pin	Notes
DB0-DB7	8-bit data bus	D22-D29	Parallel data lines
RD	Read strobe	D30	Active low read signal
WR	Write strobe	D31	Active low write signal
RS	Register select (DC)	D32	High for data, low for command
CS	Chip select	D33	Active low
RESET	Reset	D34	Active low
VCC	Power	5V	Check module voltage rating
GND	Ground	GND	Common ground
LED	Backlight	PWM pin (e.g., D6)	Brightness control

The parallel interface requires careful timing. The ILI9341 datasheet specifies a write cycle time of 100 ns minimum, which is easily met by an Arduino Mega running at 16 MHz. However, the Uno lacks enough pins for 8-bit parallel without using port manipulation, which complicates wiring. The SPI version is far more practical for beginners. The DM-TFT28-105 module, for instance, uses SPI and includes a microSD card slot that shares the SPI bus but uses a separate CS pin (often labeled SD_CS). The SD card pinout is usually: SD_CS (pin 4), SD_MOSI (shared with display MOSI), SD_MISO (shared with display MISO), SD_SCK (shared with display SCK). You must initialize the SD card with a different CS pin to avoid conflicts.

Touch Controller Pinout Details

Many 2.8-inch TFT modules include a resistive touch overlay driven by an XPT2046 or ADS7846 controller. The touch controller uses a separate SPI interface, but it can share the same MOSI, MISO, and SCK lines as the display if you use different CS pins. The touch pinout is typically: T_CS (chip select), T_DIN (MOSI), T_DO (MISO), T_CLK (SCK), and T_IRQ (interrupt). The T_IRQ pin goes low when a touch is detected, allowing you to wake the Arduino from sleep or trigger an interrupt. The XPT2046 datasheet specifies a 12-bit ADC with a maximum conversion rate of 125 kHz. For accurate touch readings, you need to send a command byte (e.g., 0x90 for X position, 0xD0 for Y position) and read back two bytes. The touch controller operates at 2.7V to 5.25V, so it is 5V tolerant. The DM-TFT28-105 module integrates this touch controller, and its pinout matches the table above. If your module lacks touch, you will only have 8 pins (VCC, GND, CS, RESET, DC, MOSI, SCK, LED) plus optional MISO.

Voltage Level and Power Considerations

The ILI9341 driver IC operates at 2.8V to 3.3V logic, but many modules include a 3.3V regulator and level shifters to accept 5V from Arduino. The DM-TFT28-105 is explicitly designed for 5V operation, meaning you can connect VCC to 5V directly. However, the logic pins (CS, RESET, DC, MOSI, SCK) are 5V tolerant, so you do not need level shifters. The backlight LED pin typically draws 20-30 mA at 3.3V, but it can be driven directly from a 5V PWM pin with a series resistor (usually 100 ohms) if your module does not have one built in. The total current draw for the display with backlight on is around 80-120 mA, which is well within the Arduino Uno’s 500 mA regulator limit. For the SD card slot, the module usually includes a separate 3.3V regulator, so you do not need to worry about voltage levels. Always measure the voltage on the VCC pin with a multimeter before connecting; some cheap modules omit the regulator and require 3.3V input, which can damage the display if you apply 5V.

Common Wiring Mistakes and Fixes

One frequent error is swapping MOSI and MISO. On Arduino Uno, MOSI is pin 11, MISO is pin 12, and SCK is pin 13. If you connect MOSI to pin 12, the display will not initialize. Another mistake is forgetting to connect the LED pin; the display will appear dead even though the driver is working. Use a PWM pin with a value of 255 (analogWrite(6, 255)) to turn the backlight on fully. The RESET pin can be tied to the Arduino reset pin via a 10k resistor, but using a separate digital pin gives you software control. If you use the same CS pin for both the display and the SD card, the SPI bus will conflict, causing garbled data. Always use separate CS pins: display CS on pin 10, SD CS on pin 4. The touch controller CS should be on a third pin, like pin 7. Some libraries, like the Adafruit_ILI9341 library, assume default pin assignments: CS=10, DC=9, RESET=8, but you can change them in the constructor. The DM-TFT28-105 module works with these defaults if you wire accordingly.

Performance Data and Timing

The SPI clock frequency for the ILI9341 can go up to 40 MHz according to the datasheet, but Arduino Uno’s SPI runs at 8 MHz (half of 16 MHz) by default. You can increase it to 16 MHz using SPI_CLOCK_DIV2, but some modules may have signal integrity issues with long wires. The typical frame rate for a 240x320 display over SPI is around 15-20 frames per second for full-screen updates, which is acceptable for static graphics but not for video. The parallel interface can achieve 30-60 fps due to the 8-bit data bus. The DM-TFT28-105 module uses SPI, so expect a maximum pixel clock of 8 MHz, translating to about 0.5 microseconds per pixel. For a full screen (240x320 = 76,800 pixels), a full update takes about 38 milliseconds, not including command overhead. In practice, you should use partial updates or DMA to improve performance. The display supports 16-bit color (65,536 colors) via RGB565 format, which requires two bytes per pixel. The SPI bus must send 2 bytes per pixel, so a full screen update sends 153,600 bytes. At 8 MHz, that takes about 19.2 milliseconds, but the ILI9341’s internal timing adds latency.

Library and Software Pin Mapping

Most Arduino libraries for the ILI9341, such as Adafruit_ILI9341, MCUFRIEND_kbv, or TFT_eSPI, allow you to define pins in the constructor. For example, using TFT_eSPI, you set the pins in the User_Setup.h file: TFT_CS 10, TFT_DC 9, TFT_RST 8, TFT_MOSI 11, TFT_SCLK 13, TFT_MISO 12, TFT_BL 6. The touch controller is handled by a separate library like XPT2046_Touchscreen, where you define T_CS 4, T_IRQ 7. The SD card uses the standard SD library with chip select pin 4. If you use the DM-TFT28-105 module, the pinout matches these defaults, making it plug-and-play with many example sketches. The module’s product page provides a wiring diagram and example code for Arduino Uno, which is invaluable for troubleshooting. Always verify the pinout with a multimeter before powering up, as some modules swap the DC and RESET pins.