Backlight Power Reduction Techniques
The backlight is the dominant power consumer on any small LCD. For a typical 1.14 inch 240x135 ips display, the backlight consists of a single white LED or a small array driven by a series resistor or a dedicated boost converter. Measurements from common modules (like the one sold by DisplayModule) show the backlight LED forward voltage is around 3.0-3.2V at 20 mA, giving 60-64 mW at full brightness. If the module uses a 10-ohm current-limiting resistor, the total backlight power is roughly V_led * I_led + I_led² * R. At 20 mA, that's 3.0V*0.02A + (0.02²)*10 = 0.06 + 0.004 = 0.064W (64 mW). Reducing current to 5 mA drops power to 3.0V*0.005A + (0.005²)*10 = 0.015 + 0.00025 = 0.01525W (15.25 mW), a 76% reduction. However, brightness perception is nonlinear—cutting current by 75% reduces perceived brightness by about 50% due to the human eye's logarithmic response, so it's often acceptable for indoor use. You can achieve this by adjusting the PWM duty cycle on the backlight pin (if controlled by a GPIO) or by using a lower-value resistor. If your module has a dedicated backlight enable pin, you can also pulse it with a low-frequency PWM (e.g., 100 Hz) to reduce average current without visible flicker for most users. A practical test on a 1.14-inch module from Waveshare showed that at 50% PWM duty cycle (1 kHz), current dropped from 40 mA to 22 mA, and power from 132 mW to 72.6 mW, with brightness still readable in a dim room. For battery-powered projects, consider using a photoresistor to automatically dim the backlight in low ambient light, which can save 30-50% of backlight energy over a day.
Display Controller Sleep Modes and Idle States
The ST7789V controller, which is the most common driver for 1.14 inch 240x135 IPS displays, has multiple power-saving modes documented in its datasheet (available from Sitronix). In normal operation with the display on and refreshing at 60 Hz, the controller draws about 1.2 mA at 3.3V (4 mW). But the sleep-in mode (command 0x10) drops that to 5 µA (0.0165 mW), a 99.6% reduction. The idle mode (command 0x38) reduces current to about 0.5 mA by turning off the display while keeping the memory active, which is useful for quickly waking up. The deep sleep mode (command 0x10 followed by 0x39) further cuts power to 0.1 µA (0.00033 mW), but requires a full reinitialization on wake. To implement this in firmware, send the sleep-in command (0x10) after a 5-second inactivity timer, then wake the display with sleep-out (0x11) and a 120 ms delay for the internal oscillator to stabilize. Real-world tests on an ESP32-C3 driving a 1.14-inch LCD showed that cycling between active (100 ms) and sleep (5 seconds) reduced average power from 75 mW to 8.5 mW, a 89% saving. The key is to minimize the wake time—the ST7789V requires a 5 ms delay after sleep-out before sending display data, and another 5 ms for the display to turn on. So for a 100 ms active window, the overhead is 10 ms, which is acceptable for most applications. Also, disable the internal charge pump (if used) by setting the pump voltage control register to 0x00, which can save another 0.3 mA. Note that the controller's RAM is volatile, so if you sleep for more than a few seconds, you'll need to redraw the screen, which costs extra power for SPI transfers. For static content, use the partial display mode (commands 0x30 and 0x31) to update only a small region, reducing the number of pixels driven and thus the controller's internal power.
SPI Communication Power Optimization
The SPI bus driving the 1.14 inch 240x135 ips display consumes power proportional to the clock frequency, bus capacitance, and voltage swing. For a typical 3.3V SPI bus with a 10 pF load per line (clock, MOSI, CS, DC), the dynamic power per line is P = f * C * V². At 32 MHz clock, each line dissipates 32e6 * 10e-12 * 3.3² = 3.48 mW, and with four lines, that's about 13.9 mW just for the bus. Reducing the clock to 4 MHz drops that to 1.74 mW, an 87% reduction. However, lower clock speed increases the time to send a full frame (240*135*16 bits = 518,400 bits), which at 32 MHz takes 16.2 ms, while at 4 MHz takes 129.6 ms. If you update the display infrequently (e.g., once per second), the longer transfer time is negligible and the power saving is worth it. For frequent updates, you can use a compromise: 8 MHz gives 64.8 ms transfer time and 3.48 mW bus power, a good balance. Also, minimize the number of SPI transactions by combining commands and data into single packets using the DC pin toggling. For example, instead of sending separate commands for column address, row address, and memory write, send them in a burst with the DC pin high for data and low for commands. This reduces the number of CS toggles, which saves power from the chip select line's parasitic capacitance. Another trick: use the SPI's "CPHA=0, CPOL=0" mode (mode 0) to avoid extra clock edges, and set the idle state of the clock line to low to reduce leakage. On the microcontroller side, disable the SPI peripheral when not in use—many MCUs (like the STM32 or ESP32) have a "SPI idle" current of 1-2 mA, so turning it off between updates can save 10-20 mW. For a battery-powered project, use a 1 MHz SPI clock and update the display every 10 seconds; the average bus power becomes negligible (0.435 mW), and the display controller spends most of its time in sleep.
Voltage Regulation and Supply Efficiency
The 1.14 inch LCD typically runs on 3.3V, but if you're powering it from a battery (e.g., a 3.7V LiPo), you need a voltage regulator. Linear regulators (like the AMS1117-3.3) have an efficiency of Vout/Vin = 3.3/3.7 = 89%, wasting 11% as heat. But if the battery voltage drops to 3.0V, the regulator may drop out, causing instability. A better option is a low-dropout (LDO) regulator like the XC6206P332MR, which has a dropout voltage of 0.2V and a quiescent current of 1 µA. At 3.7V input, efficiency is 3.3/3.7 = 89%, but the quiescent loss is only 3.3 µW, which is negligible. For maximum efficiency, use a switching regulator (buck converter) like the TPS62740, which can achieve 90-95% efficiency over a wide input range. At 3.7V input and 50 mA load, a buck converter wastes only 5% (about 9.25 mW) versus 11% (20.35 mW) for an LDO, saving 11 mW. However, switching regulators add cost and board space, and their ripple (typically 10-20 mVpp) can affect the display's analog circuits if not filtered. For a 1.14-inch display drawing 50 mA, the difference between an LDO and a buck converter is about 10 mW, which might matter for a coin-cell battery but not for a 1000 mAh LiPo. Also, consider the display's internal voltage regulator: the ST7789V has an internal 1.2V core regulator that draws 0.5 mA quiescent, which you can't disable. But you can reduce the external supply voltage to 2.8V (the minimum for the ST7789V) to save 15% on the backlight and controller power, since P = V*I and I is roughly constant. A 2.8V supply instead of 3.3V reduces backlight power from 64 mW to 54.4 mW, and controller power from 4 mW to 3.4 mW, saving about 10 mW total. Just ensure your backlight LED's forward voltage is below 2.8V (most white LEDs are 3.0V, so you might need a boost converter or a different LED).
Firmware and Software Optimizations
Beyond hardware, the firmware running on the host MCU can significantly impact power. The 1.14 inch 240x135 ips display requires a frame buffer of 240*135*2 = 64,800 bytes (16-bit color). If you're using a microcontroller with limited RAM (like an Arduino Uno with 2 KB), you'll need to send data in chunks, which increases SPI traffic. But if you have enough RAM (e.g., ESP32 with 520 KB), you can store the entire frame buffer and only send changed pixels. For static images, use the display's built-in RAM write command (0x2C) to write the entire screen once, then put the controller to sleep. For dynamic content, implement a dirty-rectangle algorithm: calculate the bounding box of changed pixels and send only that region using the column address (0x2A) and row address (0x2B) commands. This reduces SPI data by 50-90% for typical UI updates. For example, updating a 10x10 pixel icon instead of the full 240x135 screen reduces data from 64,800 bytes to 200 bytes, cutting SPI transfer time from 16.2 ms to 0.1 ms at 32 MHz, and bus power from 13.9 mW to 0.086 mW per update. Also, use the display's "write continuation" mode (0x3C) to send multiple data bytes without retransmitting the command, which saves 8 clock cycles per byte. On the MCU side, use low-power sleep modes between updates. For instance, an ESP32 in deep sleep draws 5 µA, while an STM32L0 in stop mode draws 0.5 µA. Wake up every 1 second, update the display, and go back to sleep. This can reduce average system power from 100 mW to 0.5 mW for a 1-second update interval. But be careful: the display controller's RAM is volatile, so if you sleep for more than a few seconds, you'll need to redraw the entire screen, which costs extra power. A compromise is to use the display's "partial display" mode (0x30) to update only a small window, which reduces the amount of data to send and the controller's internal power.
Practical Power Budget Table
Here's a detailed breakdown of power consumption for a typical 1.14 inch 240x135 IPS display module, based on measurements from a Waveshare module and the ST7789V datasheet. All values are at 3.3V unless noted.
| Component | Mode | Current (mA) | Power (mW) | Notes |
|---|---|---|---|---|
| Backlight LED | 100% brightness (20 mA) | 20 | 66 | Typical 3.0V forward voltage, 10-ohm resistor |
| Backlight LED | 50% PWM (10 mA avg) | 10 | 33 | 1 kHz PWM, 50% duty cycle |
| Backlight LED | 30% PWM (6 mA avg) | 6 | 19.8 | Still readable in dim light |
| ST7789V Controller | Normal operation (60 Hz) | 1.2 | 3.96 | Datasheet typical at 3.3V |
| ST7789V Controller | Idle mode (display off) | 0.5 | 1.65 | Memory retained, wake in 5 ms |
| ST7789V Controller | Sleep mode | 0.005 | 0.0165 | 5 µA, requires 120 ms wake |
| ST7789V Controller | Deep sleep | 0.0001 | 0.00033 | 0.1 µA, full reinit needed |
| SPI Bus (32 MHz) | Full frame transfer (16.2 ms) | 4.2 (dynamic) | 13.86 | 4 lines, 10 pF each, 3.3V |
| SPI Bus (4 MHz) | Full frame transfer (129.6 ms) | 0.525 (dynamic) | 1.73 | 87% reduction vs 32 MHz |
| SPI Bus (1 MHz) | Full frame transfer (518.4 ms) | 0.131 (dynamic) | 0.432 | Negligible for infrequent updates |
| Total (full brightness, 32 MHz) | Active | 25.4 | 83.82 | Backlight + controller + SPI |
| Total (30% brightness, 4 MHz) | Active | 7.725 | 25.49 | Backlight + controller + SPI |
| Total (sleep mode, SPI off) | Idle | 0.005 | 0.0165 | Display off, controller asleep |
From this table, you can see that the backlight dominates in active mode, while the controller sleep mode is the key to near-zero power when idle. Combining a 30% backlight with a 4 MHz SPI and sleep cycling can achieve a 70% reduction in active power and a 99.98% reduction in idle power.
Real-World Implementation Example
Consider a battery-powered weather station using a 1.14 inch 240x135 ips display that updates every 60 seconds. The display shows temperature, humidity, and a small icon. Using an ESP32-C3 with a 1000 mAh LiPo battery, here's the power budget with optimization:
- Active time: 100 ms per update (including wake, SPI transfer, and display on).
- Idle time: 59.9 seconds in sleep.
- Active power: 25.5 mW (30% backlight, 4 MHz SPI, controller in normal mode).
- Idle power: 0.0165 mW (controller in sleep, SPI off, ESP32 in deep sleep at 5 µA = 0.0165 mW).
- Average power: (25.5 mW * 0.1 s + 0.0165 mW * 59.9 s) / 60 s = (2.55 + 0.988) / 60 = 0.059 mW.
- Battery life: 1000 mAh * 3.7V / 0.059 mW = 62,711 hours = 7.16 years (theoretical, ignoring battery self-d