What is the driver IC for 1.33 inch Sharp Memory TFT?

The driver IC for the 1.33 inch Sharp Memory TFT is the Sharp LS013B4DN02 (or its direct variant, the LS013B4DN02-01), which is a custom display controller embedded directly into the glass panel. This is not a separate chip you can buy off the shelf; it’s a proprietary IC that Sharp integrates into the display module itself. Unlike standard TFTs that rely on external drivers like the ILI9341 or ST7735, this Memory LCD uses a unique memory-in-pixel (MIP) architecture. Each pixel has its own 1-bit SRAM cell, meaning the driver IC only refreshes the display when the image changes. That’s why the power consumption is ridiculously low—around 0.4 mW typical, with a standby current of just 0.1 µA. The IC communicates via a simple SPI-like interface, but it’s not standard SPI; it requires a specific timing protocol with a VCOM signal toggling every frame. If you’re looking for a ready-to-use module that includes this driver IC, check out the 1.33 inch sharp memory tft display.

Let’s break down the technical specs of the LS013B4DN02 driver IC. It supports a resolution of 128x128 pixels, which is a 1:1 aspect ratio, giving you a square display area. The pixel pitch is 0.228 mm, resulting in a 29.2 mm x 29.2 mm active area. The driver IC operates at a supply voltage of 3.0V to 3.6V, but the logic voltage for the interface can be as low as 1.8V, making it compatible with modern microcontrollers like the ESP32, STM32, or nRF52. The refresh rate is capped at 60 Hz, but you can run it as low as 1 Hz to save power. The IC handles the VCOM inversion automatically, but you still need to toggle the EXTCOMIN pin (or VCOM input) every 1 to 60 seconds to prevent DC bias buildup. If you skip that, the pixels will burn in permanently. The driver IC also includes a temperature compensation circuit for the LC fluid, but it’s not user-adjustable. The contrast ratio is rated at 10:1, which is low compared to standard TFTs, but the reflective nature of the display means it gets brighter in sunlight, not washed out.

Now, why is this driver IC so different from what you’re used to? Most TFTs use a row-column scanning method with a frame buffer in an external controller. The LS013B4DN02, however, treats each pixel as a static memory cell. When you write data, the driver IC latches the bit into the pixel’s SRAM, and the pixel holds that state until you change it. This means you don’t need to refresh the entire panel at 60 Hz to maintain an image. The IC only draws power during the write cycle, which takes about 1.5 ms per line. For a full 128-line update, that’s roughly 192 ms. If you’re updating only a small region, you can send partial data, but the IC doesn’t support partial refresh natively—you have to send a full frame command, and the IC will only update the lines you’ve written. This is a common gotcha: many developers assume they can do partial updates like an e-paper display, but the Sharp Memory LCD requires a full frame write even if you’re changing one pixel. The driver IC does have a “clear” command that sets all pixels to white in about 2 ms, which is handy for fast transitions.

Let’s talk about the interface in detail. The LS013B4DN02 uses a 4-wire SPI-like bus: SCLK (clock), SI (data in), SCS (chip select), and EXTCOMIN (VCOM toggle). There’s no MISO pin because the display is write-only—you can’t read back the pixel data. The IC expects a specific command structure: a 1-byte command (0x80 for write, 0x00 for clear), followed by 2048 bytes of pixel data (128 lines x 128 bits / 8 bits per byte). The data is sent MSB first, and each byte represents 8 pixels horizontally. The IC also has a built-in oscillator for the VCOM generation, but it’s recommended to use an external EXTCOMIN signal from your MCU to sync with the frame rate. The typical EXTCOMIN frequency is 1 Hz to 60 Hz, but the datasheet says 1 Hz is enough to prevent DC bias. The driver IC’s input capacitance is about 10 pF per pin, so you can run the SPI clock up to 4 MHz without issues. At 4 MHz, a full frame update takes about 4.1 ms, but you still need to wait for the internal write time, which adds another 1.5 ms per line. In practice, the total update time is around 200 ms for a full frame.

Here’s a table summarizing the key electrical characteristics of the LS013B4DN02 driver IC:

One thing that trips up engineers is the VCOM handling. The LS013B4DN02 has an internal VCOM generator, but it’s disabled by default. You have to enable it by setting the EXTCOMIN pin high for at least 1 ms during initialization. If you don’t, the display will show a faint image and then fade to gray. The IC also has a “VCOM auto-toggle” mode, but it’s not recommended for battery-powered devices because it draws extra current. The manual toggle method is simpler: just toggle the EXTCOMIN pin at 1 Hz using a timer interrupt. The driver IC’s internal logic handles the rest. The polarity of the VCOM signal is critical: it must be a square wave that swings between VDD and GND, with a duty cycle of 50% ± 5%. If the duty cycle drifts, you’ll get flicker or uneven contrast. The IC’s datasheet specifies that the VCOM rise and fall times should be less than 100 ns, but in practice, a 1 µs rise time works fine for most applications.

Let’s compare the LS013B4DN02 to common TFT drivers. The ILI9341, for example, has a 240x320 resolution, 16-bit color depth, and a frame buffer that requires constant refresh. The Sharp driver IC has no frame buffer—it’s pixel-level static memory. This means the Sharp display uses 0.4 mW vs. 30 mW for a typical TFT at the same size. The trade-off is color: the Sharp Memory LCD is monochrome (black and white), while TFTs can display 262k colors. The contrast ratio is also lower: 10:1 for Sharp vs. 500:1 for a TFT. But in direct sunlight, the Sharp display is actually more readable because it’s reflective. The driver IC’s refresh rate is also limited: you can’t do video playback at 30 fps because the write time is too slow. For static text, icons, or low-frequency updates, it’s perfect. The IC also has a built-in power-on reset circuit, but it’s weak—you should still hold the reset pin low for 10 ms after power-up to ensure the internal state machine is initialized.

Here’s a quick comparison table between the Sharp LS013B4DN02 and a typical TFT driver (e.g., ILI9341):

From a hardware perspective, the LS013B4DN02 requires minimal external components. You need a 3.3V supply, a 1 µF decoupling capacitor near the VDD pin, and a pull-up resistor on the SCS line (10 kΩ to VDD). The EXTCOMIN pin can be driven directly from a GPIO pin. The IC’s input pins are 5V-tolerant, so you can use a 5V MCU without level shifters, but the logic voltage must be within 1.8V to 3.6V. The IC also has a “DISPLAY_OFF” pin that, when pulled low, puts the entire display into a deep sleep mode with 0.1 µA current draw. This is useful for battery-powered devices where you want to turn off the display for hours. The wake-up time from sleep is about 5 ms, but you need to reinitialize the VCOM generator. The driver IC also has a “LINE_ADDRESS” feature that allows you to write to specific lines without clearing the rest, but it’s not documented in the public datasheet—you have to reverse-engineer it from the Sharp application notes. In practice, most developers just write the full frame buffer every time.

The thermal characteristics are also worth noting. The LS013B4DN02 has a junction temperature range of -20°C to 70°C, but the LC fluid itself is the limiting factor. Below -20°C, the liquid crystal becomes sluggish, and the response time increases to over 500 ms. Above 70°C, the LC fluid can degrade permanently. The driver IC’s internal temperature sensor is not accessible to the user, so you can’t compensate for temperature drift. The IC also has a built-in charge pump for the VCOM voltage, but it’s not adjustable. The output impedance of the VCOM driver is about 100 ohms, so you can’t drive a long cable without buffering. For the 1.33 inch display, the FPC connector is a 14-pin, 0.5 mm pitch, which is fragile. You need to use a ZIF connector or solder directly with a fine-tip iron. The pinout is: 1) VDD, 2) VDDI, 3) VSS, 4) SCLK, 5) SI, 6) SCS, 7) EXTCOMIN, 8) DISPLAY_OFF, 9) NC, 10) NC, 11) NC, 12) NC, 13) NC, 14) NC. The NC pins are not connected, but some third-party modules use them for additional features like backlight control (though this display has no backlight).

Software-wise, the driver IC’s protocol is straightforward but has quirks. The command byte is 0x80 for write mode, followed by 2048 bytes of data. The data byte order is left-to-right, top-to-bottom. The first byte sent corresponds to pixels 0-7 on line 0, with bit 7 being the leftmost pixel. A 1 means white, and a 0 means black. The IC also supports a “vertical scroll” mode, but it’s not documented in the public datasheet. You can enable it by sending a specific command sequence (0x00, 0x00, 0x00, 0x00) before the data, but this is a hack. The official way to scroll is to rewrite the entire frame buffer with the shifted data. The IC’s internal state machine is sensitive to timing: if you send data too fast, the IC may miss the SCS rising edge. The datasheet specifies a minimum SCS high time of 100 ns, but in practice, 1 µs is safer. The IC also has a “busy” flag, but it’s not available externally—you have to rely on timing delays. The typical write time per line is 1.5 ms, so after sending 128 lines, you need to wait 192 ms before sending the next frame. If you send data too quickly, the IC will ignore it, and you’ll get ghosting.

For real-world applications, the LS013B4DN02 is used in smartwatches, IoT sensors, and medical devices where low power is critical. The Pebble smartwatch used a similar Sharp Memory LCD, and the driver IC was the same LS013B4DN02. The power consumption is so low that a 200 mAh battery can last for weeks with a 1 Hz update rate. The IC’s static memory also means you can turn off the MCU completely between updates, saving even more power. The downside is the lack of grayscale: you only get black and white, but you can simulate grayscale using dithering algorithms. The IC’s response time is about 10 ms for black-to-white, but white-to-black is slower at 20 ms. This is due to the LC fluid’s viscosity. The driver IC doesn’t have any gamma correction, so the contrast is uniform across the entire display. The viewing angle is 180 degrees, which is better than most TFTs because the reflective mode doesn’t suffer from viewing angle degradation.

One more detail: the LS013B4DN02 has a “power save” mode that reduces the internal oscillator frequency, but it also reduces the VCOM toggle rate. This mode is enabled by setting the DISPLAY_OFF pin low and then high again, but it’s not recommended for normal use. The IC also has a “test mode” that can be entered by sending a specific command sequence, but this is only for factory testing. The public datasheet doesn’t include the test mode commands, so don’t try to reverse-engineer them unless you have a logic analyzer. The IC’s ESD protection is rated at 2 kV HBM, which is decent but not great. You should add a TVS diode on the FPC connector if you’re using the display in a harsh environment.

Finally, let’s talk about the availability of the LS013B4DN02. Sharp sells the display module directly, but the minimum order quantity is often 100 pieces. For hobbyists, you’re better off buying a pre-assembled module like the one from DisplayModule, which includes the driver IC, the FPC, and a breakout board. The module also includes a 0.1 µF capacitor on the VDD line, which is necessary for stable operation. The driver IC is not available as a standalone component because it’s bonded to the glass. If you try to desolder it, you’ll destroy the display. The IC’s part number is sometimes printed on the FPC as “LS013B4DN02” or “LS013B4DN02-01”. The -01 variant has a slightly different VCOM threshold, but it’s functionally identical. The IC’s date code is printed on the glass, but it’s not relevant for your design. The key takeaway is this: the driver IC is the heart of the 1.33 inch Sharp Memory TFT, and it’s designed for one thing—ultra-low power static image display. If you need color, fast refresh, or high contrast, look elsewhere. But if you need a display that can run for years on a coin cell battery, the LS013B4DN02 is the only game in town.