Does a 0.32 inch 800x600 micro OLED support partial refresh?

Yes, the 0.32 inch 800x600 micro OLED does support partial refresh, but it’s not a straightforward plug-and-play feature like you’d expect from a standard e-paper or some low-resolution OLEDs. The partial refresh capability depends heavily on the specific driver IC, interface protocol, and how you configure the display controller. Let me walk you through the technical specifics, because if you’re designing a wearable or a viewfinder, partial refresh can save you significant power and bandwidth, but it also introduces timing constraints.

First, the 0.32 inch 800x600 micro oled display typically uses a CMOS backplane with an active matrix pixel structure, meaning each pixel is driven by a thin-film transistor (TFT) array. The resolution is 800x600, which is SVGA class, and the pixel pitch is around 0.32 inches diagonally, so the pixel size is roughly 8.5 microns—extremely small. This high density (about 2,500 pixels per inch) means the driver IC must handle a massive amount of data. The partial refresh is implemented at the driver level, usually through a window-based addressing scheme similar to what you see in LCD controllers. For example, the driver IC (often a SSD1306-like variant but scaled for micro OLEDs, or a proprietary one like the Solomonic or ROHM series) allows you to set a column and page address range. You can write data only to a specific rectangular region of the screen, leaving the rest of the pixels in their previous state. This is not a true partial update like e-paper where only changed pixels are modified; instead, it’s a partial write to the frame buffer. The OLED pixels themselves are current-driven and will hold their state only as long as the TFT gate voltage is maintained. In static mode, the driver refreshes the entire frame at a rate of 60 Hz or higher to prevent flicker. If you use partial refresh, you must ensure the non-updated region is still being refreshed by the driver’s internal scan, or else those pixels will fade due to leakage current. The datasheet for the 0.32 inch 800x600 micro oled display specifies that partial refresh is supported via the MIPI DSI command set, specifically using the “Set Column Address” and “Set Page Address” commands (DCS commands 0x2A and 0x2B). This allows you to define a window of up to 800x600 pixels, but the minimum window size is typically 1 pixel wide and 1 line high. However, the driver must still scan the entire active area to maintain the non-updated pixels, which means partial refresh doesn’t reduce the scan rate—it only reduces the data transfer bandwidth. For example, if you update a 100x100 pixel region, you only send 10,000 pixels of data instead of 480,000, but the driver still clocks through the entire 800x600 array. This can save power in the data interface (I2C, SPI, or MIPI) but not in the pixel drive. The I2C interface, which is common for this display, runs at up to 400 kHz in fast mode, but for 800x600 at 60 fps, you’d need a data rate of about 28.8 MHz for full frame updates, which is beyond I2C’s capability. So partial refresh is almost mandatory for I2C implementations. The display module supports both I2C and MIPI DSI, but MIPI is the only practical interface for full-frame updates at 60 fps. With MIPI DSI, you can use two lanes at 500 Mbps each, which gives you 1 Gbps total bandwidth, enough for full-frame 24-bit color at 60 fps (about 691 Mbps). Partial refresh on MIPI reduces the data rate proportionally, but the driver still needs to maintain the display’s refresh rate. The driver IC’s internal oscillator runs at 10 MHz to 20 MHz, and the frame rate is set by the vertical blanking period. For partial refresh, you must keep the vertical blanking interval consistent, or you’ll get tearing artifacts. The datasheet recommends a vertical blanking of at least 10 lines for stable operation. In practice, I’ve seen engineers use partial refresh to update only a status bar or a small icon area, which reduces power consumption by about 30% to 50% on the data interface, but the overall system power (including the OLED drive) only drops by 10% to 20% because the pixel current is still flowing in the non-updated areas. The OLED pixels are current-driven, and each pixel draws about 1-2 microamps at 3.3V for typical brightness (100 cd/m²). With 480,000 pixels, that’s about 0.5 to 1 amp total current for full white, but in practice, you’re not driving all pixels at full brightness. The partial refresh doesn’t reduce the pixel current unless you also dim the non-updated area. Some driver ICs support a “partial display mode” where the non-updated region is set to a low-power state (e.g., black or off), but this is not standard for the 0.32 inch 800x600 micro OLED. The datasheet mentions “partial display mode” in the command list, but it’s only available when using the MIPI interface, not I2C. For I2C, the partial refresh is limited to writing to a window, but the driver still scans the entire array. The I2C interface has a maximum clock of 400 kHz, which translates to about 50 kB/s data rate. For an 800x600 8-bit grayscale image, that’s 480,000 bytes per frame, so a full frame update would take 9.6 seconds—impractical. So partial refresh is essential for I2C, and you’d typically update a small region like a 100x100 pixel area, which takes about 0.2 seconds. This is fine for static images but not for video. The display’s response time is about 1 microsecond, so the pixel switching is fast, but the interface bottleneck is the real issue. The partial refresh also affects the gamma correction and color calibration. The driver IC applies gamma correction per pixel, but if you update only a region, the gamma curve is applied to the new data, not the old data. This can cause a visible brightness mismatch if the gamma curve is not linear. The factory calibration for this display is done at the full frame level, so partial refresh might introduce a slight color shift in the updated region, typically less than 5% in luminance. You can compensate by adjusting the gamma registers in the driver, but that requires per-window calibration. The temperature range for partial refresh is also important. The OLED efficiency drops at low temperatures, and the driver IC’s charge pump might not maintain the voltage for partial updates below -20°C. The datasheet specifies an operating range of -40°C to +85°C, but partial refresh is only guaranteed down to -10°C due to the charge pump’s current limit. The pixel leakage current increases at high temperatures, so above 70°C, the non-updated pixels might fade faster, requiring a full refresh every 10 seconds instead of every 60 seconds. The display’s lifetime is rated at 20,000 hours to half brightness for full frame updates, but partial refresh can extend the lifetime of the updated region because it reduces the cumulative current through those pixels. However, the non-updated region might age faster if it’s constantly displaying a static image. The burn-in risk is higher for static content, so partial refresh is actually beneficial for dynamic content but not for static logos. The driver IC supports a “screen saver” mode that shifts the partial update window slightly to avoid burn-in, but this is not enabled by default. The power consumption for partial refresh varies by interface. With I2C, the interface power is about 0.1 mW for a 100x100 update at 10 fps, while the OLED power is about 100 mW for a typical image. With MIPI, the interface power is about 1 mW for the same update, but the OLED power remains the same. So the total power is dominated by the OLED itself. The display’s peak brightness is 1,000 cd/m² for full white, but in partial refresh mode, you can reduce the brightness of the non-updated region by setting the contrast register, which is a 8-bit value. This can cut the OLED power by 50% if you dim the static area to 10% brightness. The datasheet includes a “partial brightness” command (0x51) that allows per-window brightness control, but only in MIPI mode. For I2C, you have to use the global brightness register, which affects the entire display. The partial refresh also affects the frame rate. The driver IC can operate at 60 Hz, 90 Hz, or 120 Hz, but partial refresh is only stable at 60 Hz because the window addressing logic is optimized for that rate. At 120 Hz, the window update might cause tearing if the data isn’t sent within the blanking period. The vertical blanking period is 10 lines at 60 Hz, which gives you about 1.6 microseconds per line, so you have 16 microseconds to send the window data. For MIPI, that’s plenty, but for I2C, you’d need to send data at 400 kHz, which is 2.5 microseconds per byte, so a 100x100 8-bit window would take 10,000 bytes * 2.5 us = 25 milliseconds, which is longer than the blanking period. So with I2C, you’ll see tearing if you update during active display. The solution is to update during the vertical blanking period, but that requires the host to synchronize with the display’s VSYNC signal. The module has a VSYNC pin that outputs a pulse at the start of each frame, so you can use that to trigger the partial update. The datasheet specifies that the VSYNC pulse width is 1 line (about 16 microseconds at 60 Hz), and the host must send the window data within the next 10 lines. This is tight for I2C, but doable with a DMA controller. The partial refresh also works with the display’s sleep mode. In sleep mode, the driver IC stops scanning, but the frame buffer retains its data. When you wake up the display, it resumes from the last frame, so you can use partial refresh to update only the changed regions after wake. This is useful for always-on displays. The wake-up time is about 5 milliseconds, and the partial update can be sent immediately after. The display’s standby current is 10 microamps, so partial refresh can reduce the average power to under 1 mW for a low update rate. The 0.32 inch 800x600 micro OLED also supports a “tearing effect” line (TE) that indicates when the display is in the vertical blanking period. This is essential for partial refresh without tearing. The TE pin is active low, and it goes high during the blanking period. You can configure the polarity via the command 0x35. The datasheet recommends using TE for all partial refresh operations. The partial refresh window size is limited by the driver’s internal memory. The frame buffer is 800x600x24 bits, which is 1.44 MB, but the driver IC has only 1.5 MB of SRAM, so the window can be any size up to the full frame. However, the driver’s window address registers are 16-bit, so the maximum column address is 799 and the maximum page address is 599. The minimum window is 1 column by 1 row. The partial refresh also supports multiple windows in a single frame, but the driver can only handle one window per frame because the address registers are set per write. You can chain multiple writes, but each write must be within the same frame. The driver’s internal logic will update the pixels in the order they are written, so if you write two overlapping windows, the second one overwrites the first. This is useful for animations. The partial refresh also affects the color depth. The display supports 24-bit color (16.7 million colors), but in partial refresh mode, you can use 8-bit or 16-bit color to reduce data. The driver IC has a pixel format register (0x3A) that lets you set the color depth per window. For example, you can set a 100x100 window to 16-bit RGB565, which reduces the data to 20,000 bytes instead of 30,000 bytes for 24-bit. This speeds up the I2C transfer by 33%. The color depth change is global, though, so you can’t have different depths for different windows in the same frame. The partial refresh also works with the display’s rotation and mirroring features. The driver IC supports 90, 180, and 270 degree rotation via the MADCTL register (0x36). If you rotate the display, the partial refresh window coordinates are also rotated, so you need to account for that in your software. The rotation is applied at the hardware level, so the window address is remapped. For example, if you rotate 90 degrees, the column address becomes the row address. This is documented in the datasheet, but it’s easy to miss. The partial refresh also has a limitation with the display’s built-in gamma correction. The gamma curve is applied after the window write, so if you update a window, the gamma correction is applied to the new data, but the old data in the non-updated region retains its previous gamma. This can cause a slight brightness discontinuity at the window boundary, typically less than 1% in luminance. You can minimize this by using a linear gamma curve, but that reduces contrast. The factory default gamma is a 2.2 curve, which is standard for sRGB. The partial refresh also affects the display’s response time for motion. The OLED pixels have a rise time of 10 microseconds and a fall time of 20 microseconds, so for a 60 Hz refresh, the pixel is fully settled within 1 line time. But if you update a window, the pixels in that window are updated immediately, while the non-updated pixels are still in their previous state. This can cause a visual artifact where the window appears to “lag” behind the rest of the image if the window is moving. This is not a problem for static windows, but for scrolling text, you might see a smearing effect. The solution is to use a full refresh for motion content. The partial refresh is best for static icons, status bars, or text that changes infrequently. The display’s datasheet includes a “partial update” example that updates a 50x50 pixel clock icon at 1 Hz, which reduces power by 40% compared to a full refresh at 60 Hz. The example uses MIPI DSI with a 2-lane interface at 500 Mbps. The partial refresh is also supported in the display’s “low power mode,” where the driver IC reduces the scan rate to 1 Hz. In this mode, the partial refresh is limited to 1 window per second, and the non-updated region is refreshed at 1 Hz, which causes visible flicker. The flicker is 50% at 1 Hz, so it’s only suitable for very dim environments. The low power mode is intended for always-on displays where the content is static. The partial refresh in low power mode uses a different command set (0xB0 to 0xB7) that sets the window in terms of “blocks” of 8x8 pixels. This reduces the addressing overhead but limits the window granularity. The block size is 8 pixels, so the minimum window is 8x8 pixels. This is a trade-off for lower power. The 0.32 inch 800x600 micro OLED also supports a “partial display on” command (0x29) that enables the partial refresh mode, and a “partial display off” command (0x28) that reverts to full frame. The driver IC’s state machine must be in the correct mode before you send window data. If you send a partial update while in full frame mode, the driver will ignore the window address and write to the entire frame. This is a common mistake. The datasheet specifies that you must send the “partial display on” command, then set the window address, then write the data, then send the “partial display off” command if you want to return to full frame. The sequence is critical. The partial refresh also works with the display’s “invert” mode (0x20). If you invert the display, the partial refresh still works, but the colors are inverted. This is useful for night mode. The partial refresh is also compatible with the display’s “test mode” (0xE0), but that’s only for factory use. The 0.32 inch 800x600 micro OLED’s partial refresh is a robust feature, but it requires careful timing and configuration. The driver IC’s datasheet is 200 pages long, and the partial refresh section is about 20 pages. The key parameters are the window address registers, the color depth, the interface speed, and the VSYNC synchronization. If you’re using I2C, you’ll need to update at a low rate (e.g., 1 Hz to 10 Hz) to avoid tearing. If you’re using MIPI, you can update at 60 Hz with a small window. The partial refresh is also supported in the display’s “sleep out” mode, but the driver IC must be fully powered on. The partial refresh does not work in sleep mode because the driver stops scanning. The wake-up time is 5 ms, so you can wake up, send a partial update, and go back to sleep. This is a common pattern for battery-powered devices. The display’s power consumption in this pattern is about 0.5 mW average for a 1 Hz update rate. The partial refresh also supports “write continue” mode, where you can send multiple window updates without re-sending the window address. This is controlled by the command 0x3C, which sets the “write continue” flag. This reduces the overhead for multiple updates in the same frame. The driver IC’s internal FIFO is 32 bytes, so you can send up to 32 bytes of data per write without re-addressing. The partial refresh is also affected by the display’s “frame rate control” (FRC) feature. The FRC dithers the color to achieve 24-bit color from 18-bit hardware. In partial refresh mode, the FRC is applied per window, which can cause a slight pattern noise at the window boundary. The noise is about 1 LSB