What is the color depth of a 1.14 inch 240x135 screen?
The color depth of a 1.14 inch 240x135 screen is typically 16-bit (65,536 colors) or 18-bit (262,144 colors), depending on the specific driver IC and panel configuration used in the module. Most common implementations, such as those found in the 1.14 inch 240x135 ips display, rely on an 18-bit RGB interface internally, but the actual color depth exposed to the user often defaults to 16-bit via the SPI protocol to balance performance and memory usage. This is a critical spec for anyone designing embedded systems, wearables, or compact UI projects, because it directly impacts how many distinct shades you can push per pixel, the smoothness of gradients, and the overall visual fidelity on that tiny screen.
Let’s break down the technical foundation. The 1.14 inch 240x135 screen uses a TFT LCD panel with an IPS (In-Plane Switching) structure, which already gives you wide viewing angles—typically 160 degrees horizontally and vertically. But the color depth is determined by the display driver IC, often a model like the ST7735S, ILI9163, or GC9A01. These chips natively support up to 262K colors (18-bit), meaning they can handle 6 bits per channel for red, green, and blue. However, the SPI interface, which is the most common communication method for this size, usually transfers data in 16-bit packets (RGB565 format: 5 bits red, 6 bits green, 5 bits blue). That’s why you’ll see many datasheets listing 65K colors as the effective color depth. The 18-bit mode exists but requires 3-byte-per-pixel transfers, which doubles the data load and slows down the refresh rate—something you don’t want on a 240x135 resolution at 60 Hz or higher.
To put this into perspective with raw numbers: a 240x135 pixel grid has 32,400 pixels total. In 16-bit mode, each pixel consumes 2 bytes, so a full frame buffer is 64,800 bytes. In 18-bit mode, it jumps to 97,200 bytes. For a microcontroller with limited RAM, like an ESP32 or STM32, that 32 KB difference can be the deciding factor between smooth animation and stuttering. Many developers stick with 16-bit for this reason, especially when driving the screen via SPI at speeds of 20-40 MHz. The trade-off is that you lose some gradation in the green channel (6 bits vs. 5 bits), but the human eye is less sensitive to green details anyway, so it’s a practical compromise. The 1.14 inch 240x135 ips display modules often come pre-configured for 16-bit by default in their initialization code, but you can switch to 18-bit by adjusting the SPI command sequence in the driver library.
Now, let’s talk about the panel itself. The 1.14 inch diagonal measurement gives a physical active area of roughly 25.0 mm x 14.0 mm, depending on the bezel design. The pixel density is about 240 PPI (pixels per inch), which is sharp enough for text and icons at a typical viewing distance of 20-30 cm. With 16-bit color depth, you get 65,536 colors, which covers basic UI elements, graphs, and simple images without noticeable banding. But if you’re displaying photographic content or smooth gradients, 18-bit (262,144 colors) makes a visible difference—especially in the blue and red channels. For example, a sunset gradient from deep red to orange might show subtle steps in 16-bit, but in 18-bit, those steps become nearly imperceptible. The IPS technology also helps here because it maintains color consistency across angles, so the depth perception isn’t ruined by off-axis viewing.
Here’s a quick comparison table to ground the specs:
| Parameter | 16-bit (RGB565) | 18-bit (RGB666) |
|---|---|---|
| Total colors | 65,536 | 262,144 |
| Bits per channel | R:5, G:6, B:5 | R:6, G:6, B:6 |
| Frame buffer size (240x135) | 64,800 bytes | 97,200 bytes |
| SPI transfer time (40 MHz) | ~12.96 ms | ~19.44 ms |
| Typical refresh rate | 60-70 Hz | 40-50 Hz |
| Gradient smoothness | Moderate (visible steps in some cases) | High (smooth transitions) |
This table shows the real-world impact. The SPI transfer time is calculated assuming a 40 MHz clock, which is a common speed for these modules. If you’re using a slower MCU or a lower SPI clock, the 18-bit mode can drag the refresh rate below 30 Hz, causing flicker or motion blur. That’s why many manufacturers list the color depth as 65K in their product specs, even though the hardware supports more. The 1.14 inch 240x135 ips display modules on the market often include a built-in voltage regulator and level shifter to handle 3.3V logic, and the driver IC’s internal RAM is usually 240x135x18 bits, which means it always stores data in 18-bit format internally. The SPI interface just decides how to pack the data—either as 2-byte or 3-byte per pixel. So the actual color depth is a software choice, not a hardware limitation.
Another angle to consider is the gamma curve and color calibration. Most 1.14 inch screens come with a default gamma setting that’s optimized for 16-bit mode, with a gamma value around 2.2. If you switch to 18-bit, you might need to adjust the gamma correction registers in the driver IC to avoid washed-out or overly saturated colors. The datasheet for the ST7735S, for example, includes a command (0xE0 for positive gamma and 0xE1 for negative gamma) that lets you fine-tune the voltage levels for each color channel. This is crucial for applications like medical devices or industrial monitors where color accuracy matters. The 1.14 inch 240x135 ips display typically has a contrast ratio of 800:1 to 1000:1, and with 16-bit depth, the perceived contrast is still good because the LCD’s backlight brightness (usually 250-350 cd/m²) dominates the visual experience.
Let’s also talk about power consumption. The color depth affects how much data you push through the SPI bus, which directly impacts the current draw. In 16-bit mode, the screen’s typical power consumption is around 20-30 mA at full brightness (including the backlight LED). In 18-bit mode, the increased data transfer can add 5-10 mA, depending on the SPI frequency and the MCU’s processing overhead. For battery-powered devices like smartwatches or fitness trackers, this is a non-trivial difference. The 1.14 inch 240x135 ips display modules are often paired with low-power controllers like the nRF52840 or ESP32-S3, and developers will optimize the color depth to extend battery life. For example, a UI that mostly uses solid colors and simple shapes can get away with 16-bit, while a photo frame or dashboard with charts might benefit from 18-bit.
Now, let’s get into the nitty-gritty of the pixel structure. The 240x135 resolution is a non-standard aspect ratio (16:9 exactly, if you do the math: 240/135 = 1.777, which is 16:9). This is unique for small screens, as most are 240x240 or 128x128. The 16:9 ratio means you get a widescreen format, which is great for video or timeline-based interfaces. The color depth of 16-bit or 18-bit applies uniformly across all pixels, but the driver IC’s internal memory is organized as a 240x135 matrix of 18-bit words. When you send data in 16-bit mode, the driver pads the missing bits with zeros or uses a dithering algorithm internally. Some advanced drivers like the GC9A01 support dithering in hardware, which can simulate 18-bit appearance on a 16-bit interface by alternating pixel values. This is called temporal dithering or spatial dithering, and it’s a neat trick to improve perceived color depth without increasing data bandwidth. However, it can introduce flicker or noise in static images, so it’s not always enabled by default.
From a software perspective, the color depth also affects how you handle color conversion in your code. If you’re using an Arduino library like Adafruit_GFX or TFT_eSPI, you’ll configure the color space at initialization. For the 1.14 inch 240x135 ips display, the typical init sequence sets the color mode to 16-bit (0x3A command with value 0x05 for RGB565). To switch to 18-bit, you change that value to 0x06 (RGB666). But not all libraries support this, and you might need to modify the driver source. The SPI clock speed also matters: at 40 MHz, 16-bit mode gives you a theoretical maximum frame rate of about 77 Hz (64,800 bytes per frame, 40 MHz / 8 bits per byte = 5 MB/s, so 5,000,000 / 64,800 = 77 frames per second). In 18-bit mode, it drops to 51 Hz. If you’re using a slower MCU like an Arduino Uno (16 MHz), the SPI clock is limited to 8 MHz, and the frame rates drop to 15 Hz and 10 Hz respectively—too slow for smooth animation. That’s why you’ll rarely see 18-bit used on low-end hardware.
Let’s look at some real-world data from manufacturers. The 1.14 inch 240x135 ips display modules from various suppliers (like those on DisplayModule or similar) typically list the color depth as 65K in the product title, but the datasheet will mention 262K as a maximum. For example, the ST7735S driver datasheet explicitly states “262K colors” in the features section, but the application notes recommend using 65K for most SPI-based systems. The difference is that the 18-bit mode requires a 9-bit SPI transfer per byte (some drivers use 9-bit mode for command/data separation), which complicates the protocol. Most SPI controllers on microcontrollers only support 8-bit transfers natively, so 18-bit mode often requires packing three bytes into two 9-bit transfers or using a custom bit-banging approach. This adds complexity and reduces reliability. That’s why the 1.14 inch 240x135 ips display is almost always sold as a 65K-color screen, even though the panel itself can do more.
Another factor is the viewing angle and color shift. IPS panels are known for their wide viewing angles, but color depth interacts with this. At extreme angles (like 80 degrees off-axis), the perceived color difference between 16-bit and 18-bit becomes negligible because the LCD’s inherent color shift dominates. The contrast ratio also drops to about 200:1 at 80 degrees, so the subtle gradations in 18-bit are lost anyway. For most applications, the 16-bit mode is sufficient because the screen is small and viewed head-on. But if you’re building a product that will be viewed from multiple angles, like a smart home control panel mounted on a wall, the 18-bit mode might help maintain color consistency at moderate angles (up to 60 degrees). The 1.14 inch 240x135 ips display’s IPS technology ensures that the color shift is minimal compared to TN panels, but it’s still there.
Let’s also discuss the backlight and its effect on color depth. The screen uses a white LED backlight with a typical brightness of 250-350 cd/m². The backlight is PWM-controlled, usually at 1-10 kHz, and the color depth of the LCD itself is independent of the backlight. However, the backlight’s color temperature (often 6500K) can affect how the colors appear. A warm backlight (3000K) might make the 16-bit colors look more yellowish, while a cool backlight (8000K) can make them look bluish. The 1.14 inch 240x135 ips display modules typically have a fixed backlight color temperature, but some allow external PWM dimming. This doesn’t change the color depth, but it does affect the perceived dynamic range. In low-brightness conditions, the 16-bit mode’s limited color steps can become more visible because the human eye is more sensitive to small differences in dark areas. This is called the “posterization” effect, and it’s more pronounced on 16-bit screens than 18-bit ones.
From a manufacturing perspective, the color depth also influences the binning process. LCD panels are graded by their color uniformity, and screens with 18-bit capability often require tighter tolerances on the driver IC’s DAC (digital-to-analog converter) accuracy. The 1.14 inch 240x135 ips display modules are usually mass-produced with a standard 16-bit configuration because it’s cheaper to test and calibrate. The 18-bit mode might be available on higher-end versions, but you’d need to check the specific part number. For example, the ST7735S has a variant called the ST7735R that supports 18-bit natively, but it’s less common in small modules. The GC9A01 driver, on the other hand, is designed for 262K colors and is often used in round displays, but it can also drive rectangular panels like this one.
Let’s talk about the SPI command set that controls color depth. The key command is 0x3A (Interface Pixel Format), which sets the color mode. For the 1.14 inch 240x135 ips display, the typical initialization sequence includes sending 0x3A followed by 0x05 (16-bit) or 0x06 (18-bit). Some drivers also support 12-bit mode (0x03) for even lower color depth, but that’s rarely used because it looks terrible. The 18-bit mode requires that the SPI data is sent as 3 bytes per pixel, with the upper 2 bits of each byte being ignored (since the driver only uses 6 bits per channel). This means you’re wasting 2 bits per byte, which is inefficient. In contrast, the 16-bit mode packs the data perfectly into 2 bytes with no wasted bits. That’s another reason why 16-bit is the default: it’s more efficient in terms of both bandwidth and memory.
Now, let’s consider the human visual system. The 1.14 inch screen has a pixel density of 240 PPI, which is close to the “retina” threshold for a viewing distance of 30 cm (about 12 inches). At that distance, the eye can resolve about 60 pixels per degree, and 240 PPI means each pixel subtends about 0.24 arcminutes. The color depth of 16-bit (65,536 colors) is enough to cover the full sRGB gamut, which is the standard for most displays. The 18-bit mode (262,144 colors) extends beyond sRGB, but the human eye can only distinguish about 10 million colors total, so the difference is subtle. In practice, the 16-bit mode is adequate for almost all applications, except for professional photo editing or medical imaging, which you wouldn’t do on a 1.14 inch screen anyway. The 1.14 inch 240x135 ips display is designed for UI elements, text, and simple graphics, not for high-fidelity image reproduction.
Let’s look at some real-world examples. If you’re using this screen in a smartwatch, you’ll likely display watch faces, notifications, and fitness data. The 16-bit mode works fine for these, because the UI uses flat colors and simple icons. However, if you want to display a photo of a sunset or a gradient background, the 18-bit mode will reduce banding. I’ve tested this myself: on a 1.14 inch 240x135 ips display, a gradient from bright red to dark blue shows visible steps in 16-bit mode, but in 18-bit mode, the steps are smooth. The difference is most noticeable in the blue channel, because the 16-bit mode only gives 32 levels of blue (5 bits), while 18-bit gives 64 levels. The green channel has 64 levels in both modes (6 bits in 16-bit, 6 bits in 18-bit), so it’s less affected. The red channel goes from 32 to 64 levels. So the improvement is mostly in the red and blue channels.
Another angle is the impact on text rendering. The 1.14 inch screen has a resolution of 240x135, which is enough for 8-10 characters per line at a 6x8 font size. The color depth doesn’t affect text clarity directly, but it does affect anti-aliasing. If you use sub-pixel rendering (like ClearType), the 16-bit mode can introduce color fringing because the sub-pixels are not perfectly aligned. The 18-bit mode gives more accurate color blending, which reduces fringing. However, most embedded systems don’t use sub-pixel rendering because it’s computationally expensive, so this is a minor point. For anti-aliased fonts, the 16-bit mode is usually sufficient, because the human eye is less sensitive to color errors in small text.
Let’s also discuss the temperature range and its effect on color depth. The