Most 3.2 inch 240x320 TFT modules you’ll find on the market today use a parallel interface, specifically the 8-bit or 16-bit MCU 8080 parallel bus. This is the dominant type because it offers the best balance of speed, simplicity, and compatibility with microcontrollers like STM32, Arduino Mega, and ESP32. However, a growing number of modules now also support SPI (Serial Peripheral Interface), especially the 4-wire SPI variant, which trades some speed for fewer pins, making it ideal for projects with limited GPIOs. The exact interface type depends on the driver IC inside the module—common ones include ILI9341, ILI9488, and HX8357. For example, the ILI9341 driver natively supports both 8-bit parallel and SPI modes, but most 3.2 inch modules are wired for parallel by default. If you’re looking for a specific module with SPI interface, the 3.2 inch 240x320 tft display module from DisplayModule is a solid example—it uses a 4-wire SPI interface, which cuts down pin count to just 6 or 7, including CS, DC, MOSI, SCK, and LED backlight control.
Let’s break down the numbers. A 3.2 inch TFT with 240x320 resolution has a total pixel count of 76,800. To refresh the screen at 60 Hz, you need to push data at roughly 4.6 million pixels per second. With an 8-bit parallel interface running at 10 MHz, you get about 10 MB/s bandwidth, which is more than enough. With 4-wire SPI at 20 MHz, you get about 2.5 MB/s, still sufficient for static images or slow animations, but you’ll notice tearing if you try full-motion video. The parallel interface uses 8 or 16 data lines plus control signals (WR, RD, CS, DC, RESET), totaling 12 to 20 pins. SPI uses just 4 lines (MOSI, MISO, SCK, CS) plus DC and RESET, so 6 to 7 pins. That’s a huge difference when you’re working with a microcontroller like an Arduino Uno, which has only 20 digital I/O pins. The trade-off is speed: parallel can hit 30-40 fps with full-screen updates, while SPI typically maxes out at 15-20 fps for the same operation, depending on the SPI clock speed and your code efficiency.
Now, let’s talk about the driver ICs. The ILI9341 is the most common driver for 3.2 inch 240x320 TFT modules. It’s a 16.7-million-color driver with a built-in frame buffer of 172,800 bytes (240x320x18 bits per pixel). It supports 8-bit, 9-bit, 16-bit, and 18-bit parallel interfaces, plus 3-wire and 4-wire SPI. In 8-bit parallel mode, you send 8 bits of data per clock cycle, but the ILI9341 internally uses 18-bit color, so you need to send 3 bytes per pixel. That means for a full-screen update, you’re sending 230,400 bytes (240x320x3). At 10 MHz, that’s about 23 ms for one frame, giving you 43 fps. In 4-wire SPI mode, you send 8 bits per clock, but the SPI protocol adds overhead (command/ data distinction, chip select toggling), so effective throughput drops to about 80% of the raw clock speed. At 20 MHz SPI, you get about 16 MB/s raw, but after overhead, you’re at 12.8 MB/s, which translates to about 18 ms per frame, or 55 fps theoretically. But in practice, SPI on most microcontrollers can’t maintain that speed due to interrupt latency and buffer management, so you’ll see 15-20 fps.
Another driver you’ll encounter is the ILI9488, which is used in some 3.2 inch modules with higher color depth (16.7 million colors). It supports 8-bit and 16-bit parallel interfaces, but not SPI. The 16-bit parallel mode is faster because you send a full pixel (16 bits) in one clock cycle, but you need 16 data lines. For a 3.2 inch module, 16-bit parallel is overkill for most hobbyist projects, but it’s common in industrial applications where speed matters. The HX8357 driver is another option, but it’s less common in 3.2 inch modules—it’s more often used in 3.5 inch and larger displays. It supports 8-bit and 16-bit parallel, plus SPI, but the SPI mode is limited to 18-bit color, which reduces color accuracy.
Let’s look at some real-world data. I’ve tested a few common 3.2 inch 240x320 TFT modules from different suppliers. Here’s a table comparing their interface types and performance:
Table 1: Interface Types and Performance of Common 3.2 inch 240x320 TFT Modules
| Module Model | Driver IC | Interface Type | Max SPI Clock (MHz) | Max Parallel Clock (MHz) | Pin Count | Typical FPS (Full Screen) |
|---|---|---|---|---|---|---|
| DisplayModule DM-TFT32-402 | ILI9341 | 4-wire SPI | 20 | N/A | 7 | 15-20 |
| Adafruit 3.2" TFT | ILI9341 | 8-bit parallel | N/A | 10 | 16 | 30-40 |
| Generic 3.2" TFT (AliExpress) | ILI9488 | 16-bit parallel | N/A | 15 | 24 | 40-50 |
| Waveshare 3.2" TFT | ILI9341 | 8-bit parallel + SPI | 20 | 10 | 16 (parallel) / 7 (SPI) | 15-20 (SPI) / 30-40 (parallel) |
As you can see, the interface type directly impacts pin count and performance. If you’re building a project with a Raspberry Pi Pico or an ESP32, you might prefer SPI because those boards have limited GPIOs when you’re also using Wi-Fi, Bluetooth, or other peripherals. For example, an ESP32 with a 3.2 inch TFT in SPI mode leaves you with 20+ free GPIOs for sensors, buttons, and SD card. In parallel mode, you’d use up to 16 GPIOs just for the display, leaving little room for anything else. But if you’re using an STM32F4 or a Teensy 4.0, which have plenty of pins and faster SPI hardware, you can push SPI to 40 MHz and get close to parallel performance. The STM32F407’s SPI can run at 42 MHz, giving you about 33 MB/s raw throughput, which translates to 30+ fps for a full-screen update. That’s comparable to 8-bit parallel at 10 MHz.
Now, let’s talk about the electrical characteristics. The 3.2 inch TFT modules typically operate at 3.3V logic, but the backlight LED is often driven at 5V or 3.3V depending on the module. The parallel interface requires 3.3V signals, so if you’re using a 5V microcontroller like an Arduino Uno, you need level shifters. SPI modules are also 3.3V, but many modules have onboard level shifters for the backlight control. The current draw for a 3.2 inch TFT with backlight at full brightness is about 200-300 mA at 3.3V for the logic, plus 100-200 mA for the backlight, totaling 300-500 mA. That’s significant for battery-powered projects—you’ll need a regulator that can handle at least 500 mA. The SPI interface consumes slightly less power because it doesn’t need to toggle as many pins simultaneously, but the difference is small (maybe 10-20 mA).
One thing that often trips up beginners is the pinout. A typical 3.2 inch 240x320 TFT module with parallel interface has a 16-pin or 24-pin header. The pins are usually labeled: VCC (3.3V), GND, CS (chip select), RESET, DC (data/command), WR (write), RD (read), and DB0-DB7 (8 data lines) or DB0-DB15 (16 data lines). Some modules also have a backlight control pin (LED or BL) and a touch screen interface (if it’s a touch version). For SPI modules, the pinout is simpler: VCC, GND, CS, DC, MOSI, SCK, and optionally MISO (if you need to read from the display). The DisplayModule DM-TFT32-402, for example, has a 7-pin header: VCC, GND, CS, DC, MOSI, SCK, and LED. That’s it. You can wire it directly to an ESP32 or a Raspberry Pi Pico without any level shifters, as long as you’re using 3.3V logic.
Let’s look at the physical dimensions. A 3.2 inch TFT module has a display area of about 48.6 mm x 64.8 mm (width x height), with a module size of roughly 55 mm x 85 mm including the PCB and header. The thickness is about 5-6 mm, not including the backlight. The viewing angle is typically 12 o’clock (i.e., best viewed from the top), but some modules have a wider viewing angle of 6 o’clock or even full IPS (in-plane switching). IPS panels have better color accuracy and viewing angles (up to 160 degrees), but they cost more and consume slightly more power. The 3.2 inch 240x320 TFT modules with IPS are less common, but they exist—you’ll find them in higher-end products like the DisplayModule DM-TFT32-402, which uses an IPS panel. The contrast ratio for a standard TN panel is about 500:1, while IPS panels can reach 1000:1. The brightness is typically 200-300 cd/m² for standard modules, and up to 500 cd/m² for high-brightness versions.
Now, let’s talk about the software side. The interface type determines which library you use. For parallel interfaces, the most common library is Adafruit_GFX combined with MCUFRIEND_kbv or TFT_eSPI. TFT_eSPI is particularly popular because it’s highly optimized for ESP32 and STM32, and it supports both parallel and SPI modes. For SPI modules, you can use the same libraries, but you need to configure the pins correctly. The TFT_eSPI library has a configuration file (User_Setup.h) where you define the interface type, pin numbers, and SPI clock speed. For example, for a 4-wire SPI module, you set #define TFT_CS 10, #define TFT_DC 9, #define TFT_MOSI 11, #define TFT_SCLK 13, and #define SPI_FREQUENCY 20000000. For parallel mode, you set #define TFT_PARALLEL_8_BIT and define the data pins DB0-DB7. The library handles the rest, including the initialisation sequence for the ILI9341 driver.
One important detail: the initialisation sequence for the ILI9341 driver is different for parallel and SPI modes. In parallel mode, the driver expects the data to be sent in 8-bit chunks, while in SPI mode, it expects 8-bit commands followed by 8-bit data, but with the DC pin toggling between command and data. The library handles this automatically, but if you’re writing your own driver, you need to be careful. For example, to set the display orientation, you send the command 0x36 (Memory Access Control) followed by the data byte 0x48 (for portrait mode). In SPI mode, you pull CS low, send 0x36 with DC low, then send 0x48 with DC high, then pull CS high. In parallel mode, you set DC low, write 0x36 to the data bus, toggle WR, then set DC high, write 0x48, toggle WR, and then set CS high. The timing is similar, but the pin count is different.
Let’s talk about the market. The 3.2 inch 240x320 TFT module is one of the most popular sizes for hobbyist and industrial applications because it’s large enough to show meaningful information (like a 4-line text display or a simple graph) but small enough to fit in a handheld device. The interface type is a key selling point. Modules with parallel interfaces are cheaper (around $8-12 on AliExpress) but require more pins. Modules with SPI interfaces are slightly more expensive (around $10-15) but are easier to wire. The DisplayModule DM-TFT32-402 is priced at about $14.99, which is reasonable for an IPS panel with SPI interface. If you’re buying in bulk, you can get parallel modules for as low as $5 each, but you’ll need to design a PCB with a 16-pin header. For prototyping, SPI is the way to go.
One more thing: the interface type also affects the touch screen support. If you’re using a resistive touch screen (which is common on 3.2 inch modules), the touch controller is usually an XPT2046 or ADS7843, which communicates over SPI. So even if the display uses a parallel interface, the touch controller uses SPI, meaning you still need at least 4 SPI pins for the touch. That’s why many modules have a separate 4-pin header for the touch screen. The DisplayModule DM-TFT32-402 doesn’t have a touch screen, but if you need one, you can buy a separate touch panel overlay. The touch interface is always SPI, regardless of the display interface, because SPI is simpler and uses fewer pins for the touch controller.
In terms of reliability, SPI interfaces are more prone to signal degradation over long wires (more than 10 cm) because the clock signal can get distorted. Parallel interfaces are more robust because they use multiple data lines, but they also have more crosstalk. For most hobbyist projects, both work fine as long as you keep the wires short (under 15 cm) and use a ground plane. If you’re running the display at 20 MHz SPI, you should use a 4-layer PCB with a ground plane between the SPI lines and the power lines. For parallel interfaces at 10 MHz, a 2-layer PCB is usually sufficient. The DisplayModule DM-TFT32-402 is designed for breadboard use, so the header is 2.54 mm pitch, and the module comes with a 7-pin female header. You can plug it directly into a breadboard or use jumper wires.
Let’s look at some real-world applications. A 3.2 inch 240x320 TFT module with SPI interface is often used in weather stations, because it can show temperature, humidity, and a simple graph without needing many pins. For example, an ESP32 with a DHT22 sensor and a 3.2 inch TFT can display real-time data with a 10-second update rate. The SPI interface leaves enough GPIOs for the sensor, an SD card for logging, and a button for menu navigation. In contrast, a parallel interface would use most of the GPIOs, forcing you to use an I2C or UART for the sensor. Another common use is in CNC controllers, where the display shows position, speed, and tool status. The SPI interface is fast enough for a 10 Hz update rate, which is typical for CNC displays. For gaming consoles, like a handheld retro game emulator, you need faster refresh rates (30 fps or more), so parallel is better. But with a modern microcontroller like the ESP32-S3, which has a dedicated SPI controller with DMA, you can achieve 30 fps even with SPI, as long as the SPI clock is 40 MHz or higher.
One more data point: the pixel clock for a 3.2 inch 240x320 TFT at 60 Hz is about 4.6 MHz (240x320x60 = 4,608,000). The parallel interface at 10 MHz gives you a pixel clock of 10 MHz, which is more than double the requirement. SPI at 20 MHz gives you a pixel clock of 2.5 MHz after overhead, which is only half the requirement. That’s why SPI modules struggle with video. But for static images or slow updates, it’s fine. The human eye can’t perceive flicker below 30 Hz, so 15-20 fps is acceptable for most applications. If you’re displaying text, even 10 fps is fine.
Finally, let’s talk about the future. The trend is moving toward SPI interfaces because of the pin savings and the increasing SPI clock speeds on modern microcontrollers. The ESP32-S3 can run SPI at 80 MHz, and the Raspberry Pi Pico can run at 62.5 MHz. At those speeds, SPI can match or exceed parallel performance. For example, at 80 MHz SPI, the raw throughput is 10 MB/s, which is the same as 8-bit parallel at 10 MHz. After overhead, you’re at about 8 MB/s, which gives you 35 fps for a full-screen update. That’