What is the resolution of a 1.3 inch IPS LCD?

By admin

The resolution of a standard 1.3 inch IPS LCD is 240x240 pixels. That’s a square display with 240 pixels on each side, giving you a total of 57,600 individual pixels. This is the most common spec you’ll find across manufacturers like Sitronix, ILI9341, or ST7789 driver-based panels. But don’t let the small size fool you—this resolution packs a punch in terms of pixel density. At 1.3 inches diagonally, the pixel density hits roughly 261 PPI (pixels per inch). For context, that’s sharper than the original iPhone’s 163 PPI display. So if you’re building a wearable, a smartwatch face, a compact IoT dashboard, or a handheld gaming device, this screen gives you crisp text and smooth graphics without eating up PCB real estate.

Now, let’s dig deeper into what 240x240 actually means in real-world use. Each pixel is individually addressable via SPI (Serial Peripheral Interface), which is the most common communication protocol for these tiny IPS panels. The color depth is typically 16-bit (65,536 colors) or 18-bit (262,144 colors), depending on the driver IC. For example, the ST7789V controller supports 16-bit RGB565 format, where 5 bits for red, 6 bits for green, and 5 bits for blue. That gives you decent color reproduction for a small display, though not as rich as a 24-bit panel. The IPS (In-Plane Switching) technology ensures wide viewing angles—typically 80 degrees in all directions—so you don’t get color inversion or contrast loss when looking at it from the side. That’s a big deal for wearables where your wrist is constantly moving.

Let’s talk about physical dimensions. A typical 1.3 inch IPS LCD module measures about 33.5mm x 33.5mm for the active area, with the glass panel itself being around 35.6mm x 35.6mm including the bezel. The thickness usually ranges from 1.5mm to 2.5mm, depending on whether it includes a backlight or a touch overlay. The backlight is almost always a white LED array, consuming around 20-30mA at 3.3V. That’s about 66-99mW of power, which is efficient enough for battery-powered projects. If you’re using it in a low-power mode with the backlight off, the display itself draws less than 1mA in standby.

One thing that surprises many engineers is the refresh rate. These 1.3 inch IPS panels can handle frame rates up to 60Hz via SPI, but the actual throughput depends on your microcontroller’s clock speed and SPI frequency. With an 80MHz SPI clock, you can push full 240x240 frames at around 30-40 FPS. That’s smooth enough for animations, simple GUIs, or video playback at reduced quality. But if you’re trying to do high-speed rendering, you might need to use a parallel interface or a display with a built-in frame buffer. Most of these panels come with a GRAM (Graphics RAM) of 172,800 bytes (240x240x3 bytes for RGB), so you don’t need to constantly refresh the entire screen—only the changed regions.

Now, let’s compare it to other common small display resolutions. Here’s a quick table to give you perspective:

Display SizeResolutionPPIAspect RatioCommon Use
0.96 inch160x80~2082:1Smartwatch, small widgets
1.3 inch240x240~2611:1Wearables, IoT, gaming
1.44 inch128x128~1261:1Older MP3 players
1.54 inch240x240~2201:1Smartwatch, e-ink alternatives
1.8 inch128x160~1144:5Basic color screens

As you can see, the 1.3 inch 240x240 display sits in a sweet spot. It’s significantly sharper than the 1.44 inch 128x128 screen (which was common in early 2000s gadgets) and offers more screen real estate than the 0.96 inch 160x80 panels. The square aspect ratio (1:1) is ideal for circular watch faces or square UI elements, though you’ll need to handle circular clipping in software if you’re designing a round watch face.

Let’s talk about driver ICs. The most common ones for 1.3 inch IPS LCDs are the ST7789V and the ILI9341. The ST7789V is a 240x240 resolution controller with built-in charge pump for the gate driver, meaning you don’t need external negative voltage. It supports SPI (4-wire and 3-wire), as well as 8-bit parallel interface. The ILI9341, on the other hand, is more common for larger 2.8 inch displays but can also drive 240x240 panels. However, the ST7789V is more power-efficient and has a simpler initialization sequence. Most breakout boards for 1.3 inch panels use the ST7789V because it’s cheap (around $2-3 per IC in bulk) and widely available.

One important detail: the resolution 240x240 is not the same as 240x320 (common in 2.8 inch displays) or 240x240 with a different pixel arrangement. Some manufacturers label their 1.3 inch panels as “240x240” but actually use a sub-pixel layout like RGB-stripe or RGB-delta. The RGB-stripe layout is standard for IPS, giving you one red, one green, and one blue sub-pixel per pixel. This is what you want for sharp text and accurate colors. Avoid panels that use RGB-delta or pentile layouts, as they can cause color fringing at this high PPI.

Now, what about the viewing angle? IPS panels are known for their wide viewing angles, but there’s a nuance. At 1.3 inches, the viewing cone is typically 80 degrees in all four directions (left, right, up, down). That means you can see the image clearly even when looking from the side, but the contrast ratio drops from 1000:1 (typical) to around 500:1 at extreme angles. The brightness is usually 250-350 cd/m² (nits) for standard backlight, which is fine for indoor use but might be a bit dim under direct sunlight. If you need outdoor readability, look for a panel with a higher brightness (400 nits or more) or add a polarizer film.

Let’s get into the electrical side. The SPI interface typically uses 4 pins: SCK (clock), MOSI (data), CS (chip select), and DC (data/command). Some modules also include a RESET pin and a backlight control pin (PWM-capable). The operating voltage is usually 2.8V to 3.3V for the logic, but the backlight can take up to 5V. If you’re using a 5V microcontroller like an Arduino Uno, you’ll need a level shifter for the SPI lines to avoid damaging the display. The current draw during full-screen white is about 30mA for the backlight plus 5mA for the LCD controller, totaling 35mA at 3.3V. That’s about 115mW, which is reasonable for a battery-powered project.

One practical consideration: the 240x240 resolution at 1.3 inches means each pixel is about 0.13mm in size. That’s tiny. If you’re using a touch overlay (capacitive or resistive), the touch accuracy needs to be high to avoid misclicks. Most 1.3 inch IPS modules don’t come with touch built-in—you’d need to add a separate touch controller like the FT6336 for capacitive touch. But for most applications, you’ll use physical buttons or a rotary encoder instead.

Now, let’s talk about software. Driving a 1.3 inch 240x240 IPS display is straightforward with libraries like Adafruit_GFX, TFT_eSPI, or U8g2. The TFT_eSPI library by Bodmer is particularly optimized for ESP32 and STM32, supporting DMA (Direct Memory Access) for faster SPI transfers. With an ESP32 at 240MHz, you can achieve 60 FPS on a 240x240 display using 4-wire SPI at 80MHz. The frame buffer is 172,800 bytes, which fits easily into the ESP32’s 520KB SRAM. If you’re using an Arduino Uno with only 2KB SRAM, you’ll need to use a display with a built-in frame buffer (which these panels have) and only update changed regions—otherwise you’ll run out of memory.

Let’s look at a real-world example: a smartwatch face. With 240x240 pixels, you can display a full analog watch face with hour markers, minute ticks, and a seconds hand. The pixel density is high enough that the hour markers can be 2 pixels wide without looking jagged. For digital fonts, you can render 12-point text with 6-8 characters per line. That’s enough for time, date, battery level, and a notification icon. The IPS viewing angles mean you can glance at the watch without tilting your wrist perfectly.

Another use case is a handheld gaming device. The 240x240 resolution is perfect for retro games like Tetris, Snake, or Pong. You can even run a simple DOOM-like raycasting engine at 10-15 FPS, though the small screen size might make it hard to see details. The 1.3 inch size is also popular in RC (radio control) transmitters, where it shows telemetry data like battery voltage, RSSI, and GPS coordinates.

Now, a word about color accuracy. The 16-bit color depth (65,536 colors) is enough for most UI elements, but gradients can show banding. For example, a smooth gradient from red to blue will have visible steps. If you need smoother gradients, you can use dithering in software, but that increases processing time. The gamma curve is usually set to 2.2 by default, which matches most content. You can adjust the gamma via SPI commands if you need better contrast in low-light conditions.

Let’s talk about reliability. These IPS panels have a typical lifespan of 30,000-50,000 hours for the backlight LED (which is about 3-5 years of continuous use). The LCD itself doesn’t degrade significantly over time, but the polarizer can yellow if exposed to UV light. The operating temperature range is usually -20°C to +70°C, which covers most indoor and outdoor applications. If you’re using it in a car dashboard, you might need a wider temperature range (-30°C to +85°C), which some industrial-grade panels offer.

One more data point: the contrast ratio. IPS panels typically have a static contrast ratio of 800:1 to 1000:1. That means the brightest white is 1000 times brighter than the darkest black. In practice, you’ll get deep blacks for an LCD, but not as deep as OLED. The response time is around 20-30ms (gray-to-gray), which is fast enough for video playback at 30 FPS without noticeable ghosting.

If you’re looking for a specific module, the 1.3 inch 240x240 ips display from DisplayModule is a solid choice. It uses the ST7789V driver, has a 4-wire SPI interface, and includes a built-in backlight with PWM control. The module is 35.6mm x 35.6mm, with a 0.5mm pitch FPC connector. It’s compatible with Arduino, ESP32, Raspberry Pi Pico, and STM32. The datasheet specifies a typical brightness of 300 nits and a viewing angle of 80 degrees. The module also has a built-in voltage regulator, so you can power it directly from 3.3V or 5V.

Let’s compare this to other options in the market. Some 1.3 inch panels use the ILI9341 driver, which is more common for larger displays but can be overkill for 240x240. The ST7789V is more efficient and has a simpler initialization. Another option is the GC9A01 driver, which is used in some round 1.28 inch displays, but that’s a different form factor. For square 1.3 inch, ST7789V is the industry standard.

Now, let’s get into the nitty-gritty of pixel addressing. The 240x240 resolution uses a coordinate system where (0,0) is the top-left corner and (239,239) is the bottom-right. The SPI command to set the window is 0x2A (column address set) and 0x2B (row address set). You can send a burst of pixel data using 0x2C (memory write). The pixel data is sent in RGB565 format (2 bytes per pixel). So a full screen refresh requires 240x240x2 = 115,200 bytes. At 80MHz SPI, that’s about 1.44 milliseconds for the data transfer alone, plus command overhead. In practice, you’ll get around 30-40 FPS with a typical microcontroller.

One interesting fact: the 1.3 inch IPS LCD is also used in some industrial applications like handheld barcode scanners, medical devices (pulse oximeters), and smart home thermostats. The square aspect ratio is useful for displaying circular gauges or radial charts. The high PPI ensures that small text (like 8-point font) is still readable. For example, a 6x8 pixel font (common in embedded systems) will render each character as 6 pixels wide and 8 pixels tall, which is large enough to be legible at this resolution.

Let’s talk about power consumption in different modes. In active mode with the backlight on, the 1.3 inch IPS LCD draws about 35mA. In sleep mode (via SPI command 0x10), the current drops to 0.5mA. The backlight can be controlled via PWM to reduce power further. For a battery-powered wearable, you might run the backlight at 10% brightness, which cuts current to about 3.5mA. That’s efficient enough to run for days on a 200mAh LiPo battery.

One more thing: the viewing angle performance is not just about left/right. IPS panels have excellent off-axis color stability. At a 45-degree angle, the color shift is less than 10% for most colors. That’s much better than TN panels, which can show severe color inversion at extreme angles. For a smartwatch, this means you can see the screen clearly even when your arm is at an awkward angle.

Finally, let’s address a common misconception: some people think 240x240 is too low for a 1.3 inch display. But at 261 PPI, it’s actually sharper than a 24-inch 1080p monitor (which is about 92 PPI). The human eye can resolve about 300 PPI at a distance of 12 inches, so this display is close to the limit of human perception. You won’t see individual pixels unless you bring it very close to your eye. For most practical uses, it’s more than enough.

If you’re designing a product around this display, you’ll also need to consider the connector. Most 1.3 inch IPS modules use a 0.5mm pitch FPC (Flexible Printed Circuit) with 8 or 12 pins. The pinout usually includes VCC, GND, SCK, MOSI, CS, DC, RESET, and BL (backlight). Some modules also include an MISO pin for reading the display’s memory, which is useful for verifying data. The FPC is delicate, so you’ll want to use a ZIF (Zero Insertion Force) connector on your PCB.

In terms of software optimization, you can use double buffering to avoid tearing. Allocate a 115,200-byte buffer in RAM, draw your frame there, then send it to the display via SPI. This ensures smooth animations. On an ESP32 with PSRAM, you can even triple-buffer for 60 FPS. On a lower-end MCU like the RP2040, you might need to use partial updates—only send the pixels that changed. The ST7789V supports partial display mode, where you can update a rectangular region without refreshing the whole screen.

One more data point: the gamma curve. The ST7789V has a programmable gamma curve with 14 positive and 14 negative voltage levels. You can adjust these via SPI commands to fine-tune the color balance. For example, you can increase the red gamma to make skin tones look warmer, or decrease the blue gamma to reduce eye strain at night. The default gamma is usually set for a 2.2 curve, which matches sRGB standards.

Let’s wrap up the technical details with a quick spec sheet for a typical 1.3 inch IPS LCD:

<
ParameterValue