To update a 1.77 inch screen quickly, you need to bypass the default frame buffer delays and directly manipulate the display driver’s register set via SPI or MCU interface. The key is reducing the time between pixel data writes and the vertical sync cycle. For a typical ST7735S-based
1.77 inch 128x160 tft display, the maximum SPI clock frequency is 15 MHz, which gives you a theoretical pixel transfer rate of about 1.875 MB per second. But in practice, the overhead from command bytes, chip select toggling, and data/command (DC) pin switching cuts that down to roughly 1.2 MB per second. At 128x160 resolution with 16-bit color (RGB565), each frame requires 40,960 bytes of pixel data. That means a single frame takes about 34 milliseconds to push over SPI at 15 MHz, not accounting for the display’s internal refresh cycle. The ST7735S itself has a frame rate of around 60 Hz, so the display refreshes its internal buffer every 16.67 milliseconds. If you’re writing data slower than that, you’ll see tearing or partial updates. To get a truly fast update, you must either use the MCU’s hardware SPI with DMA (Direct Memory Access) or switch to a parallel 8-bit interface if your microcontroller supports it. The ST7735S supports both 4-wire SPI and 8-bit parallel MCU modes. In parallel mode, the data bus runs at up to 20 MHz, and you can push pixel data at 20 MB per second, dropping the frame write time to just over 2 milliseconds. But that requires at least 8 GPIO pins plus control lines, which most small MCUs like the ESP32 or STM32 can handle, but Arduino Uno cannot without bit-banging. On the software side, the display driver library you use matters a lot. Adafruit’s ST7735 library, for example, uses a blocking write function that waits for the SPI transaction to complete before returning. That’s fine for simple graphics but terrible for fast updates. If you switch to a library like TFT_eSPI, which uses non-blocking DMA transfers on ESP32, you can queue up multiple frames and let the SPI controller handle the data transfer in the background. On an ESP32 at 240 MHz, with DMA and SPI at 40 MHz (overclocked from the typical 15 MHz), you can achieve a full-screen update in under 5 milliseconds. That’s because the DMA engine moves data from memory to the SPI FIFO without CPU intervention, and the CPU can continue executing other tasks. For a 1.77 inch 128x160 TFT display, the pixel clock in the ST7735S is internally set to about 1.5 MHz for the display’s own scanning, but that’s independent of the write speed. The real bottleneck is the MCU’s ability to feed data fast enough. If you’re using a Raspberry Pi Pico with its PIO (Programmable I/O), you can bit-bang SPI at 50 MHz, which is way beyond the ST7735S’s rated maximum. But the ST7735S datasheet specifies a maximum SPI clock of 15 MHz for reliable operation, so pushing it to 50 MHz can cause data corruption. You’ll need to check the actual silicon behavior—some batches handle 20 MHz fine, others fail at 18 MHz. Another factor is the frame buffer management. Many libraries use a full-screen buffer in RAM, which on a 1.77 inch screen means 40,960 bytes of RAM for the pixel data. On an Arduino Uno with only 2 KB of SRAM, that’s impossible. So you have to write directly to the display without buffering, which means you’re limited by the SPI write speed. On an ESP32 with 520 KB of SRAM, you can double-buffer: write to a back buffer in RAM, then swap buffers and send the new buffer to the display via DMA. This eliminates tearing because the display always sees a complete frame. The swap itself is just a pointer change, so it’s instantaneous. But the DMA transfer still takes time. If you need to update only a portion of the screen, you can use the ST7735S’s window address mode (CASET and RASET commands). Instead of writing all 40,960 bytes, you set a rectangular region and write only the pixels in that region. For a 50x50 pixel area, that’s 5,000 bytes, which at 15 MHz SPI takes about 4.2 milliseconds. That’s fast enough for simple animations like a moving cursor or a digital clock. The ST7735S also supports partial display mode (via the VSCRDEF command), which lets you scroll a portion of the screen without rewriting the entire frame. This is useful for text scrolling or status bars. The scrolling happens in hardware, so the CPU only needs to update the new pixels entering the scroll area. For a 128x160 display, if you scroll a 10-pixel-high strip, you only rewrite 1,280 bytes per frame, which is under 1 millisecond at 15 MHz SPI. But the scrolling direction is fixed to vertical, and you can’t scroll horizontally without rewriting the whole row. On the hardware side, the display module itself introduces latency. The ST7735S has a built-in gate driver and source driver that scan the panel row by row. The typical row scan time is about 10 microseconds per row, so for 160 rows, the full scan takes 1.6 milliseconds. That’s just the internal scanning, not the data write. If you write data faster than the scanning, the display will buffer the incoming data in its internal line buffer. The ST7735S has a 128x16-bit line buffer, meaning it can hold one row of 128 pixels (16-bit each) at a time. So if you write a full frame, you’re writing 160 rows, but the display only holds one row at a time and then shifts it to the column drivers. This means the write speed is limited by the row scan time, not just the SPI speed. If you write data at 15 MHz, you can fill a row in about 8.5 microseconds (128 pixels * 16 bits / 15 MHz), but the display needs 10 microseconds to scan that row. So the write is actually faster than the scan, meaning you’ll have to wait for the scan to complete before writing the next row. That’s why the effective frame rate is capped at around 60 Hz—the display’s internal scan rate. To get around this, you can use the ST7735S’s vertical blanking interval. The datasheet doesn’t explicitly expose VBLANK, but you can read the status register (RDDST) to check if the display is in the vertical blanking period. During VBLANK, the display is not scanning rows, so you can write data faster without waiting for row scans. But the VBLANK period is only about 1.5 milliseconds per frame at 60 Hz, so you have a narrow window to write data. If you can write the entire frame within that 1.5 milliseconds, you get a glitch-free update. At 15 MHz SPI, you need 34 milliseconds to write a full frame, so that’s impossible. But if you’re only updating a small region, say 10 rows, you can write those 1,280 bytes in 1.07 milliseconds, which fits in the VBLANK window. This is how high-speed oscilloscope displays or game consoles update small areas without tearing. Another trick is to use the ST7735S’s MADCTL register to flip the display orientation. If you rotate the display 90 degrees, the row and column scan directions change. This can affect how fast you can update vertical vs horizontal lines. For example, if you’re updating a vertical bar graph, it’s faster to write columns instead of rows because the display scans rows. But the ST7735S doesn’t support column-wise scanning natively—it always scans rows. So to update a vertical line, you have to write each pixel in the column, which is 160 pixels, but the display will spread them across multiple rows. The window address mode helps here: you can set a 1-pixel-wide column and 160-pixel-high row, and write all 160 pixels in one burst. That’s 320 bytes, which at 15 MHz SPI takes 0.27 milliseconds. That’s fast enough for real-time updates like a waveform. On the power side, the ST7735S’s typical current consumption is 5 mA for the logic and 20 mA for the backlight. If you’re updating the display rapidly, the backlight current doesn’t change, but the logic current spikes during data writes. The SPI interface draws about 2 mA per MHz of clock, so at 15 MHz, the SPI logic draws 30 mA peak. That’s within the limits of most MCU GPIO pins, but if you’re using a battery-powered device, you’ll want to minimize the number of updates. For a 1.77 inch 128x160 TFT display, the typical refresh rate is 60 Hz, but you can reduce it to 30 Hz or 15 Hz to save power. The ST7735S supports a sleep mode (SLPIN command) that drops current to 0.1 mA, but waking up takes 120 milliseconds, so it’s not suitable for fast updates. A better approach is to use the display’s idle mode (IDMON command), which reduces the frame rate to 30 Hz and cuts current by half. The table below summarizes the key performance metrics for updating a 1.77 inch ST7735S display:
| Update Method | Interface | Clock Speed | Full Frame Time | 50x50 Region Time | RAM Required | CPU Load |
|---|
| Blocking SPI (Arduino) | 4-wire SPI | 8 MHz | 64 ms | 7.8 ms | 0 bytes | 100% |
| Blocking SPI (ESP32) | 4-wire SPI | 15 MHz | 34 ms | 4.2 ms | 0 bytes | 100% |
| DMA SPI (ESP32) | 4-wire SPI | 40 MHz | 12.8 ms | 1.6 ms | 40,960 bytes | 5% |
| 8-bit Parallel (STM32) | 8-bit 8080 | 20 MHz | 2.1 ms | 0.26 ms | 0 bytes | 70% |
| DMA Parallel (STM32) | 8-bit 8080 | 20 MHz | 2.1 ms | 0.26 ms | 40,960 bytes | 2% |
| PIO SPI (Raspberry Pi Pico) | 4-wire SPI | 50 MHz | 10.2 ms | 1.3 ms | 0 bytes | 30% |
The data in the table assumes the ST7735S is running at its default 60 Hz refresh rate and that the SPI transactions include the necessary command and data overhead. For the DMA cases, the CPU load is low because the DMA controller handles the transfers, but the RAM buffer is required. The 8-bit parallel interface is clearly the fastest for full-frame updates, but it consumes more GPIO pins. On a 1.77 inch 128x160 TFT display, the physical pixel pitch is 0.22 mm, and the viewing angle is 120 degrees typical. The ST7735S supports 262K colors (6-bit per channel), but the 16-bit RGB565 format gives 65K colors, which is what most libraries use. The color depth doesn’t affect update speed because the data bus width is fixed. If you’re using a 4-wire SPI with 8-bit data, you send two bytes per pixel, so the pixel count is the same regardless of color depth. The display’s response time is 15 milliseconds typical, which is the time it takes for the liquid crystal to change state. That’s slower than the SPI write speed, so even if you write data in 2 milliseconds, the display will take 15 milliseconds to show the new image. This is a physical limitation of the LCD panel, not the driver. For fast updates, you need to consider the panel’s response time. If you’re displaying a scrolling text, the human eye can perceive motion blur if the response time is too slow. The ST7735S’s 15 ms response time is typical for TN panels, but if you need faster, you’d need an IPS panel, which has a response time of 25 ms to 30 ms. So the 1.77 inch 128x160 TFT display is actually a TN panel, which is faster than IPS for pixel transitions. The contrast ratio is 400:1 typical, and the brightness is 250 cd/m² with the backlight at full current. The backlight is a white LED with a forward voltage of 3.0V and current of 20 mA. If you’re updating the display quickly, the backlight should be kept on constantly because turning it on and off adds 10 milliseconds of delay due to the LED’s rise time. The ST7735S also has a built-in voltage generator for the LCD bias, which takes 10 milliseconds to stabilize after power-up. So if you’re cycling the display on and off for fast updates, you’ll lose that time. The display module itself (the 1.77 inch 128x160 TFT display) typically includes a 0.5 mm thick glass with a 0.2 mm polarizer. The total module thickness is about 2.5 mm. The connector is a 0.5 mm pitch FPC with 8 pins for SPI or 16 pins for parallel. The pinout varies by manufacturer, but the standard SPI pinout is: VCC, GND, CS, RESET, DC, MOSI, SCK, and LED. The RESET pin has a 10 µs minimum pulse width, so you can reset the display quickly if needed. The DC pin must be set to command mode (low) or data mode (high) before each byte. The chip select pin must be low for the entire transaction. If you’re using multiple displays on the same SPI bus, you need to handle CS toggling, which adds 1 µs per transaction. For fast updates, it’s better to use a dedicated SPI bus for each display. The ST7735S supports a maximum of 4 displays on the same bus if you use separate CS pins, but the bus capacitance will limit the clock speed. At 15 MHz, the bus capacitance should be less than 50 pF per line. The FPC cable adds about 10 pF per inch, so a 2-inch cable adds 20 pF. The MCU’s GPIO pin adds another 10 pF. So the total capacitance is about 30 pF, which is fine for 15 MHz. But if you push to 40 MHz, you need to keep the trace length under 2 inches. The display’s internal timing is controlled by the ST7735S’s oscillator, which runs at 1.5 MHz typical. The oscillator frequency determines the row scan rate and the frame rate. You can change the oscillator frequency by writing to the FRMCTR1 register, but the datasheet warns against it because it can cause display flicker. The default frame rate is 60 Hz, but you can set it to 80 Hz by increasing the oscillator frequency. However, the panel’s response time is 15 ms, so at 80 Hz, the pixels won’t have time to fully transition, resulting in ghosting. So 60 Hz is the sweet spot for most applications. For a 1.77 inch 128x160 TFT display, the pixel clock is 1.5 MHz, which means the display can accept 1.5 million pixels per second from its internal scan. But the SPI interface can supply data at 15 million bits per second, which is 1.875 million bytes per second, or about 0.94 million pixels per second (since each pixel is 2 bytes). So the SPI interface is actually slower than the internal pixel clock for a full frame. That’s why the DMA approach is important: it ensures that the SPI is always busy sending data, so the display never has to wait for the next pixel. If you’re using a microcontroller with a cache, like the ESP32, the cache can prefetch the pixel data from flash memory, reducing the latency. The ESP32’s cache line size is 32 bytes, so it’s efficient for reading 16 pixels at a time. The flash read speed is 80 MHz, so the cache can fill faster than the SPI can consume. The actual bottleneck becomes the SPI bus itself. The ST7735S’s SPI interface has a 32-byte FIFO buffer, so you can send up to 32 bytes in one burst without waiting. The DMA controller on the ESP32 can be programmed to fill this FIFO continuously. The DMA descriptor chain can be set up to send a full frame in one go, with the DMA interrupt firing when the transfer is complete. This reduces CPU overhead to almost zero. In practice, a full-frame update on an ESP32 with DMA at 40 MHz takes about 12.8 milliseconds, which is faster than the display’s 60 Hz refresh cycle (16.67 ms). So you can update the display at 60 Hz without tearing, but you need to synchronize the DMA transfer with the display’s vertical sync. The ST7735S doesn’t have a hardware VSYNC pin, but you can read the status register to detect the vertical blanking period. The status register is read via SPI with a command byte, which takes 10 microseconds. You can poll this register in a loop, but that wastes CPU time. A better approach is to use a timer interrupt that fires every 16.67 milliseconds and