What is the refresh method of a 1.33 inch Sharp Memory TFT?
The refresh method of a 1.33 inch Sharp Memory TFT is fundamentally different from standard LCD or OLED displays. Instead of constantly refreshing the entire screen at a fixed rate (like 60Hz), it uses a memory-in-pixel (MIP) architecture. Each pixel contains its own 1-bit SRAM memory cell, meaning the display only needs to update when the image changes. Once data is written, the pixels hold their state without any power draw, and no periodic refresh is required. This is a key differentiator: the display is static until you command it to change. For example, if you show a static image at 10:00 AM, it will remain perfectly visible at 10:00 PM without any controller intervention, consuming zero power in between. The actual refresh operation is a partial or full rewrite of the pixel memory, triggered by a SPI command. The display supports a partial update mode where only a specific region is rewritten, drastically reducing power consumption and latency. The full refresh of the entire 128x128 pixel array takes about 20 milliseconds at a 10MHz SPI clock, but partial updates can be as fast as 1-2 milliseconds for small regions. This method is not a scan-line refresh like traditional TFT; it's a memory write operation. The data is latched into the pixel SRAM cells via a row and column driver, and the display controller (like the Sharp LS013B7DH03) handles the timing. The refresh is event-driven, not time-driven. This means you can update the 1.33 inch sharp memory tft display at 1Hz, 10Hz, or even 100Hz if you need animation, but the power consumption scales linearly with update frequency. At 0 updates per second, power is zero. At 1 update per second, typical current draw is around 1.5 microamps. This is a massive advantage for battery-powered devices like e-paper badges, smart home sensors, or wearable prototypes.
The refresh method relies on a specific command sequence. The display uses a 3-wire SPI interface (SCLK, MOSI, CS) plus an EXTCOMIN pin. The EXTCOMIN pin is critical: it toggles the polarity of the pixel voltage to prevent DC bias buildup. Without this, the liquid crystal material would degrade. The refresh cycle starts by pulling CS low, then sending a 16-bit command (0x01 for VCOM toggle, 0x02 for clear, 0x03 for write). The pixel data is sent as a bitmap, where each byte represents 8 pixels. The display's internal logic decodes the row and column addresses. For a full refresh, you send 128 rows x 16 bytes per row = 2048 bytes. After the last byte, you pull CS high, and the display latches the data into the SRAM cells. The EXTCOMIN pin must be toggled at least once every 60 seconds to maintain image quality. Many drivers implement a timer interrupt that toggles EXTCOMIN every 1-10 seconds, even if no image update occurs. This is not a refresh of the pixel data, but a polarity reversal. The pixel memory retains its state, but the voltage across the liquid crystal is reversed. This is a unique requirement of the Sharp Memory LCD technology. The refresh method also supports a "write mode" where you can update only a specific row. For example, to change a single pixel, you send a row address, then the 16 bytes for that row, and the rest of the display remains unchanged. This is extremely efficient for partial updates, like updating a clock display every second. The total time for a partial row update is about 100 microseconds at 10MHz SPI, which is far faster than a full frame buffer update.
From a hardware perspective, the refresh method is governed by the Sharp LS013B7DH03 controller. This controller has a 128x128 SRAM array that maps directly to the pixel grid. The data is written in a "line-by-line" manner, but it's not a raster scan. You can write rows in any order. The controller also has a "clear" command that sets all pixels to white (or black, depending on the configuration). This is a single command that takes 20 milliseconds, and it's useful for initializing the display. The refresh method does not require a frame buffer on the host microcontroller because the display has its own memory. This is a huge advantage for low-memory MCUs like the ATtiny85 or STM32G030. The host only needs to send the bitmap data when the image changes. For static images, the host can go into deep sleep mode, waking only to toggle EXTCOMIN every 10 seconds. The power consumption during sleep is less than 1 microamp. The refresh method also supports a "sleep mode" command that turns off the internal oscillator and driver circuits. In this mode, the display retains the image but consumes only 0.1 microamps. To wake it, you need to send a specific command sequence. This is useful for devices that are stored for long periods. The refresh method is not compatible with standard TFT timing controllers like ILI9341 or ST7735. You need a dedicated driver library, like the one from Sharp or the open-source SharpMemoryLCD library for Arduino. The library handles the EXTCOMIN toggling, the SPI command sequences, and the bitmap conversion. The refresh rate is limited by the SPI speed and the host processor. At 10MHz SPI, the theoretical maximum full refresh rate is about 50Hz (20ms per frame). But in practice, most applications use 1-10Hz to save power. The display can also be driven at 3.3V or 5V logic, but the internal voltage is 3.3V. The refresh method is robust against electromagnetic interference because the SRAM cells are static. However, the EXTCOMIN signal must be clean; a noisy EXTCOMIN can cause flicker or image retention.
Let's look at some concrete numbers. The following table shows the power consumption vs. refresh rate for a typical setup with a 3.3V supply and a 10MHz SPI clock:
| Refresh Rate (Hz) | Average Current (µA) | Power (µW) | Notes |
|---|---|---|---|
| 0 (static) | 0.1 | 0.33 | Only EXTCOMIN toggling |
| 1 | 1.5 | 4.95 | Typical for clock updates |
| 10 | 15 | 49.5 | Suitable for slow animations |
| 50 | 75 | 247.5 | Maximum full refresh rate |
This table shows that even at 10Hz, the power consumption is only 50 microwatts, which is orders of magnitude lower than a standard 128x128 TFT display (which would consume 5-10 milliwatts at the same resolution). The refresh method is also highly efficient for partial updates. For example, updating a single row (16 bytes) at 1Hz consumes about 0.2 microamps. This is because the SPI transaction is very short. The data for a single row is 16 bytes, which takes 12.8 microseconds at 10MHz. The controller then takes about 100 microseconds to latch the data into the pixel array. The total energy per row update is about 0.4 microjoules. This is ideal for applications like e-ink style displays, but with faster update times. The refresh method also supports a "VCOM toggle" command that can be sent without updating the pixel data. This is used to prevent DC bias. The toggle command is a single byte (0x01) and takes 10 microseconds. The recommended practice is to toggle EXTCOMIN every 1-10 seconds. Some implementations use a hardware timer on the MCU to generate a 1Hz square wave on the EXTCOMIN pin. This is the most efficient method because it doesn't require any SPI communication. The display's internal circuitry detects the rising and falling edges and toggles the polarity. This is a common technique in commercial products like the Pebble smartwatch, which used a Sharp Memory LCD. The Pebble's refresh method was exactly this: it updated the display only when the watch face changed, and it used a hardware timer to toggle EXTCOMIN every second. The result was a battery life of 7-10 days on a 140mAh battery.
From a software perspective, the refresh method requires careful handling of the SPI bus. The display is not a standard SPI device; it uses a 9-bit or 16-bit command mode. The first bit of each 9-bit word indicates whether it's a command (0) or data (1). Many microcontrollers have hardware support for 9-bit SPI, but if not, you can emulate it with 8-bit transfers. The Sharp library typically uses a 16-bit command format where the high byte is the command and the low byte is the data. The refresh method also requires a "clear" command before writing the first frame, to avoid a ghost image. The clear command sets all pixels to white, and it takes 20 milliseconds. After that, you can write the image data. The image data must be in a specific format: each byte represents 8 pixels, where bit 7 is the leftmost pixel. A 1 bit means white (or black, depending on the polarizer orientation). The default polarizer is normally white, so a 1 bit means the pixel is off (white), and a 0 bit means the pixel is on (black). This is the opposite of many other displays. The refresh method also supports a "invert" command that flips the polarity of all pixels. This is useful for changing the background color without rewriting the entire frame. The invert command is a single byte (0x04) and takes 10 microseconds. This is a common trick for creating a "night mode" or "dark mode" interface. The refresh method is also compatible with a "sleep" command that turns off the internal oscillator. In sleep mode, the display retains the image but consumes less than 0.1 microamps. To wake it, you need to send a "wake" command (0x05) and then wait 10 milliseconds for the oscillator to stabilize. This is useful for devices that are in a low-power state for most of the time.
The refresh method is not without limitations. The display has a limited viewing angle compared to IPS LCDs. The contrast ratio is about 10:1, which is lower than a standard TFT (1000:1). The refresh method also has a "ghosting" effect if you update the display too quickly. This is because the liquid crystal material has a response time of about 10 milliseconds. If you update the display faster than this, the pixels may not fully switch, resulting in a faint image of the previous frame. This is similar to the "ghosting" seen on e-paper displays. To mitigate this, you can insert a "clear" command between frames, but this increases the update time. The maximum practical update rate for a full frame is about 30Hz, but at this rate, the ghosting is noticeable. For most applications, 1-10Hz is sufficient. The refresh method also requires a stable power supply. The internal voltage generator is sensitive to noise. If the supply voltage drops below 2.7V, the display may lose its image. This is a common issue with battery-powered devices. To solve this, you can use a low-dropout regulator (LDO) with a 3.3V output. The display also has a temperature range of -20°C to +70°C, but the refresh method may need to be adjusted at extreme temperatures. At low temperatures, the liquid crystal response time increases, so you may need to increase the update time. At high temperatures, the contrast ratio may decrease. The Sharp datasheet recommends a maximum update rate of 60Hz at 25°C, but this is not achievable in practice due to ghosting.
From a design perspective, the refresh method is ideal for applications that require a static image for most of the time. Examples include:
- Smart home thermostats: Display the temperature and setpoint, update only when the temperature changes (every 10-30 seconds).
- Wearable fitness trackers: Show the time and steps, update every minute. The display can be turned off entirely between updates.
- Industrial sensors: Show a reading that changes every few minutes. The display can be in sleep mode for 99% of the time.
- E-paper badges: Show a static image for hours or days. The display is updated only when the badge is reprogrammed.
In all these cases, the refresh method saves significant power. For example, a thermostat with a standard TFT display might consume 10mW continuously, resulting in a battery life of a few weeks. With the Sharp Memory LCD, the same thermostat consumes 50µW on average, resulting in a battery life of several years. The refresh method also allows for a simpler PCB design. The display only needs 4 pins (VCC, GND, SCLK, MOSI, CS) plus EXTCOMIN. There is no need for a backlight, which saves space and cost. The display is also thin (1.2mm) and lightweight (3 grams), making it suitable for portable devices. The refresh method is also compatible with a wide range of microcontrollers, from 8-bit AVRs to 32-bit ARM Cortex-M. The SPI speed can be as low as 1MHz, which is fine for slow updates. The library code is typically less than 2KB of flash memory, which is small enough for low-end MCUs. The display also has a built-in temperature sensor that can be read via SPI. This is useful for adjusting the update rate based on temperature. The temperature sensor has an accuracy of ±2°C, which is sufficient for most applications.
One important detail: the refresh method requires a specific initialization sequence. The first time you power up the display, you must send a "clear" command to set all pixels to white. Then you must toggle the EXTCOMIN pin at least once every 60 seconds. If you don't, the display may suffer from image retention. The image retention is temporary and can be cleared by a full refresh. But if you ignore it for hours, the liquid crystal may become permanently damaged. The recommended practice is to toggle EXTCOMIN every 1-10 seconds, even if the display is not being updated. This is done by a hardware timer on the MCU. The timer interrupt is very short (10 microseconds), so it doesn't affect the main program. The refresh method also supports a "standby" mode where the display is turned off but the image is retained. In standby mode, the power consumption is 0.1 microamps. To enter standby, you send a "sleep" command. To wake, you send a "wake" command and then wait 10 milliseconds. This is useful for devices that are in a low-power state for most of the time. The refresh method is also robust against power loss. If the power is cut, the display retains the image indefinitely. This is because the SRAM cells are static. When power is restored, the display will show the same image as before. This is a key advantage over e-paper displays, which require a power-on reset to clear the image. The Sharp Memory LCD is also faster than e-paper. A full refresh takes 20 milliseconds, while e-paper takes 1-2 seconds. This makes it suitable for applications that require occasional updates, like a digital clock or a weather station.
In terms of data integrity, the refresh method uses a simple CRC check? No, it doesn't. The Sharp Memory LCD does not have any error detection or correction. The data is written directly to the SRAM cells. If the SPI bus is noisy, the image may have corrupted pixels. This is a known issue. To mitigate it, you can use a higher SPI clock speed (10MHz) to reduce the time the bus is exposed to noise. You can also add a hardware filter on the CS line. Some designs use a "write twice" approach: write the same data twice, and the second write overwrites any errors. This doubles the update time, but it improves reliability. The display also has a "test mode" command that reads back the pixel data. This is useful for debugging. The test mode is not documented in the public datasheet, but it's available in the Sharp application note. The refresh method is also sensitive to the EXTCOMIN signal. If the EXTCOMIN signal is too slow (less than 1Hz), the display may show a flicker. If it's too fast (more than 100Hz), the display may consume more power. The optimal frequency is 1-10Hz. The EXTCOMIN signal can be generated by a PWM output on the MCU. The duty cycle doesn't matter; only the frequency matters. The display's internal circuitry detects the edges. The refresh method is also compatible with a "dual display" configuration where two Sharp Memory LCDs are connected to the same SPI bus. Each display has a separate CS line. This is useful for applications that require a larger display area. The refresh method for each display is independent. You can update one display while the other is static. This is a common technique in smartwatches with a circular display and a circular bezel.
To sum up the technical details: the refresh method is a memory write operation, not a scan-line refresh. The display uses a 128x128 SRAM array that holds the pixel state. The update is triggered by a SPI command that writes the bitmap data to the SRAM cells. The display does not need any periodic refresh. The EXTCOMIN pin toggles the polarity of the liquid crystal voltage to prevent DC bias. The power consumption is proportional to the update frequency. At 0 updates per second, the power is 0.33 microwatts. At 1 update per second, the power is 4.95 microwatts. The maximum full refresh rate is 50Hz, but the practical limit is 30Hz due to ghosting. The display is ideal for battery-powered devices that require a static image for most of the time. The refresh method