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

The resolution of a 2.8 inch TFT display for Arduino is almost universally 240x320 pixels, with a pixel density of roughly 143 PPI (pixels per inch). This is the standard for the common ILI9341 or HX8357 driver-based modules you’ll find on Amazon, AliExpress, or specialty stores like Adafruit. However, don’t let the modest number fool you—this resolution is a deliberate engineering choice that balances cost, processing power, and readability for microcontroller-based projects. Let’s break down the hard facts, the technical constraints, and the real-world implications of that 240x320 spec.

Why 240x320 is the Default and Not Higher

The 240x320 resolution on a 2.8 inch diagonal gives you a 4:3 aspect ratio, which is a legacy standard from early mobile phones and PDAs. The physical dimensions are approximately 56.16mm x 43.20mm (2.21" x 1.70") for the active area, with a dot pitch of 0.234mm. This isn’t arbitrary—it’s the sweet spot for 8-bit and 16-bit microcontrollers like the ATmega328P (Arduino Uno) or ESP32. Pushing higher resolutions like 480x640 or 720x1280 would require significantly more RAM for frame buffering. For example, a 240x320 frame at 16-bit color (RGB565) needs 153,600 bytes (240 * 320 * 2). The Arduino Uno has only 2KB of SRAM, so you can’t buffer a full frame—you rely on the TFT controller’s internal RAM (typically 172,800 bytes for the ILI9341). A 480x640 frame would need 614,400 bytes, which exceeds the controller’s built-in memory and would force you to use external RAM or a much more expensive driver chip. That’s why 240x320 is the practical ceiling for most hobbyist-level TFTs.

Pixel Density and Readability

At 143 PPI, the 2.8 inch TFT is not retina-grade, but it’s perfectly readable for text and icons when viewed from a typical distance of 20-30cm. For comparison, a 2.8 inch 320x240 display (QVGA) has a lower PPI of about 143, while a 3.5 inch 480x320 display has a PPI of 165. The difference is subtle but noticeable if you’re displaying small fonts (e.g., 8-point sans-serif). The 240x320 resolution lets you comfortably display 20 characters per line at 12-point font with 16 lines of text, assuming a 16x16 pixel character cell. For graphics, you can render a 80x60 pixel icon with decent detail, but you’ll see pixelation on curves. The driver ICs handle this with sub-pixel rendering (though rarely used on Arduino) and dithering, but the raw resolution is what it is.

Color Depth and Refresh Rate

Most 2.8 inch TFTs for Arduino claim 262K colors (18-bit), but they actually operate in 16-bit RGB565 mode (65,536 colors) by default. The ILI9341 controller supports 18-bit (262,144 colors) but only when using the 18-bit parallel interface, which most Arduino shields don’t use. The SPI interface typically limits you to 16-bit color. The refresh rate is around 60Hz for static images, but over SPI, you’ll see a maximum of 15-20 full-frame updates per second (FPS) at 24MHz SPI clock. With a 2.8 inch 240x320 display, you can push a 10MHz SPI clock on an Arduino Uno (due to the ATmega328P’s SPI hardware limitations), which yields about 10 FPS for full-screen fills. The pixel clock rate for the display itself is 6.25MHz, meaning it takes about 12.3ms to scan one full frame (320 * 240 * 2 bytes / 6.25e6). That’s actually faster than the SPI throughput, so the bottleneck is always the microcontroller, not the display.

Interface Options and Wiring

The 2.8 inch TFT displays come in two main flavors: 8-bit parallel (8080-style) and 4-wire SPI. The SPI version uses 5-6 pins (CS, DC, MOSI, SCK, RST, LED) and is the most common for Arduino because it saves GPIO. The 8-bit parallel version uses 8 data pins plus control pins (13-16 total), which is impractical for an Uno but works on a Mega or Due. The SPI clock speed is typically 24MHz for the display controller, but the Arduino’s SPI library caps out at 8MHz on the Uno (due to the prescaler). On an ESP32, you can run the SPI at 40MHz, which gives you about 25 FPS for full-screen updates. The 2.8 inch size is also the largest that comfortably works with the SPI interface without noticeable flicker—larger sizes (3.5" or 4") start to show tearing because the SPI bandwidth can’t keep up with the larger frame buffer.

Backlight and Power Consumption

The backlight on a 2.8 inch TFT is typically 4 white LEDs in series, drawing about 80-100mA at 3.3V (around 320mW). The display controller itself draws 10-15mA in active mode. Total power consumption is around 350-400mW, which is manageable for a USB-powered Arduino (500mA limit). The resolution doesn’t directly affect power consumption—it’s the backlight that dominates. The pixel array draws negligible current (less than 1mA) because the TFT cells are voltage-driven, not current-driven. The 240x320 resolution means 76,800 pixels, each with a thin-film transistor that consumes about 0.1µA when active. That’s 7.68mA total for the pixel array, but the controller’s internal logic and oscillator add more. The SPI interface also adds 1-2mA per pin when toggling at 24MHz.

Touchscreen Variants

Many 2.8 inch TFT modules include a resistive touchscreen overlay, which adds a four-wire analog interface. The touch resolution is not the same as the display resolution—it’s analog, typically 12-bit ADC (4096x4096 steps) on the X and Y axes, but the effective touch accuracy is about 2-3% of the screen size, meaning you can reliably detect touch points within about 10-15 pixels of the intended location. That’s fine for button presses but not for precise drawing. The touch layer adds about 0.5mm thickness and reduces brightness by 10-15% due to the air gap. The touch controller (often the XPT2046) communicates over SPI and shares the same bus as the display, but you need a separate CS pin. The 240x320 resolution is actually overkill for resistive touch—you can’t achieve pixel-level accuracy due to the analog noise and the physical deformation of the overlay.

Compatibility with Arduino Libraries

The most popular library for 2.8 inch 240x320 TFTs is the Adafruit_GFX combined with the Adafruit_ILI9341 or MCUFRIEND_kbv library. The GFX library abstracts the resolution and provides functions like tft.fillScreen(), tft.drawPixel(), and tft.drawBitmap(). The library handles the SPI communication and the controller-specific commands. The 240x320 resolution is hardcoded into the library’s init sequence, but you can change it with tft.setRotation() to get 320x240 (landscape) or 240x320 (portrait). The library uses a 16-bit color space, so you have 65,536 colors to work with. The frame buffer is not stored in the Arduino’s RAM—it’s on the ILI9341’s GRAM, so you can only draw pixel-by-pixel or use the hardware acceleration commands (like fill rectangle, draw line, or push pixels). The library’s performance is limited by the SPI speed—on a 16MHz Arduino, a full-screen fill takes about 200ms (5 FPS), while a 100x100 pixel rectangle fill takes about 12ms.

Physical Dimensions and Mounting

The 2.8 inch TFT module (including the PCB) is typically 50mm x 85mm x 7mm (with the SD card slot and touch controller on the back). The active area is 56.16mm x 43.20mm, with a bezel of about 2-3mm on each side. The module has four mounting holes (3mm diameter) at the corners, spaced 44mm x 74mm apart. The SPI pins are usually broken out to a 2x8 header (0.1" pitch) on the edge. The 240x320 resolution gives you a dot pitch of 0.234mm, which is large enough that you can see individual pixels from 10cm away. The viewing angle is typically 12 o'clock (best viewed from the top), with a contrast ratio of 500:1 and a brightness of 250-300 cd/m² (with backlight at full). The response time is 15ms (rise) and 20ms (fall), which is fine for static images but can cause ghosting on fast-moving objects.

Comparison with Other Common Sizes

Let’s compare the 2.8 inch 240x320 TFT with other popular sizes to give you a data-driven perspective:

Size	Resolution	PPI	Pixel Count	Frame Buffer (16-bit)	Typical SPI FPS (Uno)
1.8"	128x160	111	20,480	40,960 bytes	25 FPS
2.4"	240x320	167	76,800	153,600 bytes	15 FPS
2.8"	240x320	143	76,800	153,600 bytes	15 FPS
3.5"	480x320	165	153,600	307,200 bytes	8 FPS
4.0"	480x320	145	153,600	307,200 bytes	8 FPS

As you can see, the 2.8 inch and 2.4 inch share the same resolution, but the 2.8 inch has a lower PPI (143 vs 167) because the pixels are spread over a larger area. This means the 2.8 inch display is slightly less sharp but easier to read from a distance. The 3.5 inch display has double the pixel count, but the frame buffer size also doubles, which is why the FPS drops. The 2.8 inch is a sweet spot for readability and performance.

Real-World Use Cases and Limitations

With a 240x320 resolution, you can build a functional weather station, a game like Pong or Tetris, a data logger with graphs, or a simple menu system. The resolution is adequate for displaying 10-12 lines of text (with 20 characters per line at 12-point font) or a 120x160 pixel image with decent detail. The main limitation is the lack of anti-aliasing—the Adafruit_GFX library doesn’t support it, so text and lines look jagged. You can mitigate this by using larger fonts (e.g., 24-point) or bitmaps with pre-rendered anti-aliased text. The 240x320 resolution is also not suitable for complex GUI elements like drop-down menus or scrollable lists—you’ll need to implement scrolling manually or use a library like TFT_eSPI that supports hardware scrolling. The ILI9341 controller has a vertical scrolling feature (via the VSCRDEF command), but it’s rarely used in Arduino projects because the library support is limited.

Driver IC Variations

Not all 2.8 inch 240x320 TFTs use the same driver IC. The most common are ILI9341 (80% of modules), HX8357 (10%), and ST7789 (5%). The ILI9341 is the most compatible with Arduino libraries, but the HX8357 is sometimes used in modules with a higher refresh rate (up to 60 FPS over SPI) because it supports a 4-line SPI interface with a 32-bit command format. The ST7789 is more common in 1.3" and 1.5" displays but appears in some 2.8" modules. The resolution is the same across all drivers, but the initialization sequence and command set differ. If you buy a generic module, check the driver IC by looking at the chip markings (e.g., ILI9341V or HX8357-D). The 240x320 resolution is always the same, but the color order (RGB vs BGR) and the gamma curve can vary, which affects color accuracy. You can calibrate this with the tft.setGamma() function in the MCUFRIEND library.

Why Not 480x640 on a 2.8 Inch?

You might wonder why there aren’t 2.8 inch TFTs with 480x640 resolution (like a smartphone display). The answer is cost and driver complexity. A 480x640 display would require a driver IC with at least 614,400 bytes of GRAM, which is 4x the ILI9341’s capacity. The IC would be larger, more expensive, and require a higher pin count (e.g., 24-bit parallel interface). The SPI interface would be too slow to update the display at an acceptable rate—even at 40MHz, you’d get only 3 FPS for full-screen updates. The 2.8 inch size is also too small to benefit from the higher resolution—the human eye can’t distinguish pixels at 300 PPI from a normal viewing distance, so 480x640 would be wasted on a 2.8 inch screen. That’s why you only see 480x640 on 3.5" or larger displays. The 240x320 resolution is a deliberate trade-off to keep the cost under $10 and the compatibility with 8-bit microcontrollers.

How to Get the Most Out of the Resolution

To maximize the 240x320 resolution, use the TFT_eSPI library instead of Adafruit_GFX. TFT_eSPI is optimized for the ILI9341 and supports hardware acceleration, dithering, and 16-bit color. It also supports frame buffer mode (if you have external RAM), which lets you double-buffer the display for tear-free animation. With TFT_eSPI, you can achieve 30 FPS on an ESP32 at 240x320 resolution by using the DMA (Direct Memory Access) feature. The library also supports 8-bit parallel mode on the ESP32, which gives you 60 FPS at the same resolution. The 240x320 resolution is also ideal for sprite-based games—you can have 32x32 pixel sprites with 8-bit transparency, and you can move them around without flicker because the ILI9341 supports windowed updates. The key is to use the tft.setAddrWindow() and tft.pushColors() functions to update only the changed region, not the entire screen.

Reliability and Long-Term Use

The 2.8 inch TFT modules are generally reliable for 10,000+ hours of operation, but the backlight LEDs are the most likely failure point. The LEDs have a typical lifespan of 20,000 hours at full brightness, but the heat from the module can reduce that to 10,000 hours if the ambient temperature is above 40°C. The 240x320 resolution doesn’t affect reliability—it’s the driver IC and the PCB traces that matter. The ILI9341 is rated for 100,000 write cycles to the GRAM, which is effectively unlimited because each pixel write is a single cycle. The SPI interface is also robust, but the flexible flat cable (FFC) on some modules can break after 500-1000 insertions if you’re using a socket. The 2.8 inch size is also less prone to mechanical stress than larger displays because the glass substrate is thicker (0.5mm vs 0.3mm on 3.5" displays).

Where to Buy and What to Look For

When buying a 2.8 inch TFT for Arduino, look for modules that explicitly state the ILI9341 driver and include a 5V compatible logic level converter (most modules run on 3.3V logic but have a 5V input for the backlight). The best option is a 2.8 inch tft display module for arduino that comes with a pre-soldered header, a touchscreen, and an SD card slot. The SD card slot is useful for storing images or fonts, but it uses the SPI bus as well, so you’ll need to manage the CS pin. The 240x320 resolution is standard, but some modules have a 320x240 orientation (landscape) by default, so you may need to