What is the communication protocol for a 1.33 inch Sharp Memory TFT?

The communication protocol for a 1.33 inch Sharp Memory TFT is a proprietary serial interface that operates similarly to SPI (Serial Peripheral Interface) but with a few distinct twists. Specifically, these displays—like the LS013B7DH03 or LS013B7DH06 from Sharp—use a 3-wire or 4-wire serial bus that combines a serial clock (SCLK), serial data input (SI), and a chip select (CS) signal, with an optional EXTCOMIN pin for DC balancing. The protocol is not standard SPI because it lacks a dedicated MISO line for data readback; it’s strictly write-only from the host microcontroller to the display. The display updates only when the CS line transitions from high to low, which triggers a full frame refresh. This is critical because the Memory LCD technology relies on a unique pixel architecture that holds its state without continuous power, so the protocol must handle the specific timing of the VCOM inversion signal to prevent image sticking. The Sharp Memory LCD datasheet specifies a minimum SCLK frequency of 1 MHz and a maximum of 10 MHz, with a typical operation at 4 MHz for balanced power consumption and update speed. The data frame is 16 bits per pixel, where the first 2 bits are dummy bits, followed by 14 bits of pixel data (0x0000 for white, 0x3FFF for black, with intermediate grayscales possible but rarely used due to the 1-bit per pixel native mode). The display resolution is 128x128 pixels, so a full frame update requires 128 * 128 * 2 = 32,768 bytes of data, which at 4 MHz SCLK takes about 65.5 milliseconds—fast enough for static images but not for video. To understand the protocol in depth, you need to look at the signal timing. The CS line must be held low for the entire transmission of a frame, and the SCLK is active on the rising edge. The SI line carries the data, and the EXTCOMIN pin is toggled at a specific rate—typically 1 to 60 Hz—to invert the polarity of the liquid crystal and prevent DC bias buildup. The datasheet for the LS013B7DH03 recommends a minimum EXTCOMIN pulse width of 1 microsecond, and the toggling must be synchronized with the frame updates. If you skip the EXTCOMIN signal, the display will show burn-in after a few hours. The protocol also includes a special command: sending a 0x0000 word followed by the CS going high triggers a “clear” operation, but this is not a command in the traditional sense—it’s just the first pixel data being all zeros. The display controller, which is embedded in the glass, interprets the data sequentially from top-left to bottom-right, row by row. There is no addressable RAM; the display is a shift register that directly drives the pixels. This means you cannot update a single pixel without rewriting the entire frame, which is a major constraint for animations. The 1.33 inch Sharp Memory TFT is often used in low-power applications like e-ink replacements, smartwatches, or IoT displays because it consumes only about 15 microamps at 3.3V when idle, and about 1.5 milliamps during a full frame update. The communication protocol is designed to minimize power: the display only draws current when the CS line is active, and the SCLK can be gated off between updates. The EXTCOMIN signal is usually generated by a timer on the host MCU, but some modules include an onboard oscillator that drives it automatically. For example, the 1.33 inch sharp memory tft display from DisplayModule integrates a built-in EXTCOMIN generator, so you only need to handle the 3-wire SPI. The pinout for that module is: Pin 1 (CS), Pin 2 (SCLK), Pin 3 (SI), Pin 4 (VCC 3.3V), Pin 5 (GND), and Pin 6 (EXTCOMIN, but it’s internally connected to a 1 Hz oscillator). The protocol timing for that module is relaxed: you can use any SPI library on an Arduino or ESP32, but you must set the SPI mode to Mode 0 (CPOL=0, CPHA=0) and set the data order to MSB first. The CS line must be toggled for each frame, not for each byte, because the display expects a continuous stream of 16-bit words. One common mistake is assuming that the Sharp Memory LCD uses standard SPI with a command/register structure. It does not. There are no commands like “set contrast” or “sleep mode”—the display is always on when powered, and the only way to change the image is to rewrite the entire frame. The protocol is purely data-driven. The EXTCOMIN signal, if not handled correctly, can cause visible flicker at 1 Hz, but many implementations use a 60 Hz toggle to make it imperceptible. The trade-off is that higher EXTCOMIN frequencies increase power consumption by about 10% at 60 Hz compared to 1 Hz. The datasheet for the LS013B7DH03 specifies that the EXTCOMIN pulse must be at least 1 microsecond wide, and the time between pulses must be between 1/60 and 1 second. If you use a 60 Hz toggle, the display will have a slight ghosting effect during fast updates, but this is acceptable for most applications. The protocol also has a specific requirement for the initial power-up sequence. After applying VCC, you must wait at least 10 milliseconds before toggling CS low to start the first frame. The display will show random pixels if you send data immediately. The recommended sequence is: power on, wait 10 ms, set CS low, send 32,768 bytes of pixel data (128 rows * 128 columns * 2 bytes per pixel), set CS high, then toggle EXTCOMIN after a delay of 1 ms. The EXTCOMIN toggle must occur after the CS goes high, not during the data transfer, because the display uses the EXTCOMIN edge to latch the new frame. If you toggle EXTCOMIN while CS is low, the display may corrupt the current frame. For developers using microcontrollers, the typical implementation uses a hardware SPI peripheral with a DMA channel to send the frame buffer. The frame buffer is a 128x128 array of 16-bit words, but you can use a 1-bit per pixel format if you map each pixel to either 0x0000 (white) or 0x3FFF (black). The display’s contrast is fixed at about 10:1, and the viewing angle is 180 degrees, which is typical for reflective LCDs. The communication protocol is unidirectional, so you cannot read back the current pixel state. This means you must maintain a shadow frame buffer in the MCU’s RAM to track what’s on the display. The 1.33 inch Sharp Memory TFT has a pixel pitch of 0.153 mm, giving it a resolution of 128x128 with a 1.33 inch diagonal. The display module’s PCB typically includes a 0.1-inch pitch header, making it breadboard-friendly. The protocol’s robustness is decent, but it’s sensitive to noise on the CS line. If the CS line glitches during a frame update, the display will show a partial image or a black screen. Using a dedicated GPIO pin for CS with a pull-up resistor is recommended. The SCLK frequency should not exceed 10 MHz, as the internal shift register may miss bits. At 10 MHz, the frame update time drops to 26.2 milliseconds, but the display’s response time is about 30 milliseconds, so you won’t see any improvement beyond 8 MHz. The power consumption at 10 MHz is about 2.5 milliamps, which is fine for battery-powered devices if you update infrequently. The Sharp Memory LCD technology is also used in the 1.33 inch version for industrial applications where ultra-low power is critical. The communication protocol is the same across all Sharp Memory LCDs, from 1.33 inch to 3.7 inch, so you can reuse the same driver code. The only difference is the frame buffer size. For the 1.33 inch, it’s 32,768 bytes; for a 2.7 inch 400x240 display, it’s 192,000 bytes. The protocol does not support partial updates, but you can reduce power by only updating the display when the image changes. The EXTCOMIN signal must continue to toggle even when the display is not being updated, because the pixel voltage decays over time. The typical decay time is about 1 second at 25°C, so the EXTCOMIN must toggle at least once per second to maintain the image. If you stop the EXTCOMIN, the display will fade to black in about 10 seconds. One practical tip: when using the 1.33 inch Sharp Memory TFT with an Arduino, you can use the Adafruit_SHARP_MemoryLCD library, but you must modify the pin assignments. The library uses a 4-wire SPI with a separate EXTCOMIN pin, but the DisplayModule version has EXTCOMIN internally connected. You can leave the EXTCOMIN pin unconnected on the Arduino side. The library’s refresh rate is typically 1 Hz, but you can increase it to 60 Hz by changing the timer interrupt. The display’s response time at 60 Hz is still acceptable for text updates, but for graphics, you’ll see a slight blur if you update faster than 30 Hz. The protocol’s data format is big-endian, meaning the most significant bit of each 16-bit word is sent first. The first two bits are ignored, so you can send 0x0000 or 0x3FFF as the 14-bit pixel data. The display’s controller expects the first pixel to be at the top-left corner, and the last pixel at the bottom-right corner. If you send the data in reverse order, the image will be mirrored. The display does not have a hardware reset pin; you can reset it by cycling power or by holding CS low for 100 milliseconds. The 1.33 inch Sharp Memory TFT is also known for its high contrast ratio of 10:1 and its ability to work in direct sunlight because it’s reflective. The communication protocol is simple enough to implement in bare-metal C without any libraries. The key is to ensure that the EXTCOMIN signal is toggled at a consistent rate, ideally using a hardware timer. The display’s datasheet specifies that the EXTCOMIN pulse width must be at least 1 microsecond, and the toggling rate must be between 1 Hz and 60 Hz. If you use a 1 Hz rate, the display will have a visible flicker that some users find annoying. A 60 Hz rate is flicker-free but increases power consumption by about 0.5 milliamps. In terms of electrical characteristics, the display operates at 3.3V with a tolerance of +/- 0.3V. The input pins are 5V tolerant, so you can use a 5V Arduino without level shifters. The current draw during a frame update is about 1.5 milliamps at 3.3V, and the idle current is 15 microamps. The EXTCOMIN signal draws about 10 microamps when toggling at 1 Hz. The total power consumption for a device that updates once per minute is about 0.5 milliwatts, making it ideal for battery-powered applications. The protocol’s timing constraints are not strict, but you must ensure that the SCLK frequency is stable. If you use a software SPI bit-banged implementation, the display will work as long as the SCLK period is at least 100 nanoseconds. The CS line must be held low for the entire frame, and you must not insert any gaps between bytes. The display’s internal shift register will reset if the CS line goes high mid-frame, so you must send all 32,768 bytes in one continuous burst. This is why DMA is recommended for high-speed updates. The 1.33 inch Sharp Memory TFT is also available with a built-in backlight, but the standard version is reflective and requires no backlight. The communication protocol is the same for both versions. The backlight version typically has an additional pin for the LED, which is driven by a separate PWM signal. The backlight current is about 20 milliamps at 3.3V, which is much higher than the display itself, so it’s often used only in low-light conditions. For developers who want to use this display with a Raspberry Pi, you can use the SPI interface with the spidev driver. The typical setup uses GPIO 10 (MOSI), GPIO 11 (SCLK), and GPIO 8 (CS). The EXTCOMIN signal can be generated by a GPIO pin toggled by a timer. The Python library for the Sharp Memory LCD is available on GitHub, but you must adjust the frame buffer size to 32,768 bytes. The display’s refresh rate on a Raspberry Pi is limited by the SPI speed, which is typically 32 MHz, but the display’s maximum is 10 MHz, so you can set the SPI speed to 8 MHz for reliability. The protocol’s robustness is also affected by the cable length. If you use long wires, the signal integrity may degrade, causing flickering or missing pixels. Using twisted-pair wires for SCLK and SI, and keeping the CS line short, is recommended. The display’s input capacitance is about 10 picofarads, so it’s not a heavy load. The EXTCOMIN signal is a square wave, and the display’s internal circuitry uses it to drive the VCOM voltage. If the EXTCOMIN signal is noisy, the display may show a checkerboard pattern. Using a 100 nanofarad capacitor between VCC and GND near the display module helps filter noise. The 1.33 inch Sharp Memory TFT is a niche product, but its communication protocol is well-documented in the Sharp datasheet. The protocol is essentially a 3-wire serial interface with a separate EXTCOMIN signal, but many modules integrate the EXTCOMIN generator, so you only need to handle the 3-wire SPI. The display’s low power consumption and high contrast make it a good choice for applications where battery life is critical. The protocol is not compatible with standard TFT displays, so you cannot use a standard TFT library without modification. The pixel format is 1-bit per pixel, but you can use 14-bit grayscale by sending values between 0x0000 and 0x3FFF, though the display’s response is not linear, so you may need a gamma correction table. The display’s operating temperature range is -20°C to +70°C, and the protocol works reliably across this range. At low temperatures, the display’s response time increases to about 100 milliseconds, so you may need to reduce the update rate. At high temperatures, the display’s contrast may drop slightly, but the protocol remains stable. The display’s life expectancy is about 50,000 hours of continuous operation, but the EXTCOMIN signal must be toggled continuously to avoid permanent damage. If you stop the EXTCOMIN for more than 10 seconds, the display will show a permanent ghost image that can only be erased by a full frame update with the correct EXTCOMIN timing. The communication protocol for the 1.33 inch Sharp Memory TFT is straightforward but requires attention to the EXTCOMIN timing. The display’s unique memory-in-pixel technology means that the protocol is optimized for low power and high contrast, not for speed. The maximum update rate is about 30 frames per second, but the practical limit is 10 frames per second due to the display’s response time. The protocol is a good fit for embedded systems that need a static display with occasional updates, such as e-ink replacements, but it’s not suitable for video or fast animations. The 1.33 inch Sharp Memory TFT is a reliable choice for applications where power consumption is more important than update speed.