How to drive a 1.33 inch Sharp Memory TFT display?
To drive a 1.33 inch Sharp Memory TFT display, you need to interface it with a microcontroller using a SPI bus, because the display relies on a memory-in-pixel architecture that retains image data without constant refresh. This specific display, the 1.33 inch sharp memory tft display, uses a 1-bit per pixel memory cell at each pixel location, meaning it only requires power to update the image, not to hold it. The display operates at a resolution of 128x128 pixels, which gives you 16,384 pixels total, and each pixel can be either black or white, so no grayscale or color is supported. The driver IC is typically the Sharp LS013B7DH03 or a compatible variant, and it communicates over a 3-wire or 4-wire SPI interface, with a maximum clock speed of 1 MHz for reliable operation. You need to supply a logic voltage of 3.0V to 3.6V, typically 3.3V, and the display draws around 10 µA in static mode, rising to about 200 µA during updates, making it extremely power-efficient for battery-powered projects.
The driving process starts with initializing the SPI bus on your microcontroller, like an Arduino Uno, ESP32, or STM32. You set the clock polarity to 0 and phase to 0, meaning the data is sampled on the rising edge of the clock. The display uses a chip select pin (CS) to enable communication, and a serial clock (SCLK) to synchronize data transfer. The data line (MOSI) sends commands and pixel data, but you don't need a MISO line because the display is write-only. The display also has an EXTCOMIN pin, which is critical for preventing DC bias buildup on the liquid crystal. You must toggle this pin at a frequency between 1 Hz and 60 Hz, typically 30 Hz, using a timer interrupt on your microcontroller. If you leave EXTCOMIN at a static level, the display will suffer from image retention or permanent damage within hours. Some modules integrate this signal internally, but the bare display requires external generation.
To update the display, you send a 16-bit command followed by pixel data. The command format is: first, you bring CS low, then send 8 bits for the command byte, followed by 8 bits for the line address. For example, to write a single line, you send 0x01 as the command, then the line number from 0 to 127. After that, you send 128 bits of pixel data, where a 1 represents black and a 0 represents white, or vice versa depending on the polarity setting. You can send all 128 lines in one burst by setting the command to 0x00, which writes to all lines sequentially. The data is sent MSB-first, and each byte represents 8 pixels horizontally. For a full frame update, you need to send 16,384 bits, which at 1 MHz takes about 16.4 milliseconds, though the actual time is longer due to overhead. The display updates line by line, and you must wait for the previous line to finish before sending the next, but the datasheet specifies a minimum delay of 1 microsecond between commands.
One common mistake is not handling the EXTCOMIN signal properly. You can generate it using a PWM output from your microcontroller, set to a 50% duty cycle at 30 Hz. For example, on an Arduino, you can use Timer1 to output a 30 Hz square wave on pin 9. Alternatively, you can use a simple delay loop in your main code, but that blocks other operations, so a timer is better. The display also has a VCOM pin that you can leave floating if EXTCOMIN is used, but some modules require it to be connected to ground. Check your specific module's datasheet, because the pinout varies. The 1.33 inch Sharp Memory TFT display typically uses a 14-pin FPC connector with 0.5mm pitch, and you need a matching breakout board or solder directly to the pads. The pinout includes: pin 1 for CS, pin 2 for SCLK, pin 3 for MOSI, pin 4 for VDD (3.3V), pin 5 for VSS (ground), pin 6 for EXTCOMIN, pin 7 for DISP (display on/off), and pin 8 for LED (backlight, if present). Note that this display is reflective, so it has no backlight; the LED pin is for an optional front light module that is not included.
For power consumption, the display is a standout. In static mode, it draws only 10 µA at 3.3V, which is 0.033 mW. During a full update, it draws 200 µA for about 20 milliseconds, which is 0.66 mW for that burst. If you update once per second, the average power is around 0.02 mW, making it ideal for e-paper-like applications. Compare this to a standard TFT display that draws 50 mA even when showing a static image. The trade-off is that the Sharp Memory TFT is monochrome and has a slower update rate, but for data displays like weather stations, clocks, or status indicators, it's excellent. The contrast ratio is typically 10:1, and the viewing angle is 180 degrees, so it looks the same from any angle. The display is also sunlight-readable because it reflects ambient light, unlike transmissive LCDs that wash out in bright light.
To drive it with a specific microcontroller, here are practical steps. On an Arduino Uno, you can use the SPI library, but you need to set the clock speed to 1 MHz or lower, because the default 4 MHz can cause errors. Use SPI.begin() with SPI.setClockDivider(SPI_CLOCK_DIV16) for 1 MHz. For the EXTCOMIN signal, use Timer1 to generate a 30 Hz interrupt. Here's a code snippet structure: in setup(), set CS, SCLK, MOSI, and EXTCOMIN pins as outputs, then start SPI. Then attach a timer interrupt that toggles EXTCOMIN every 16.67 milliseconds. The main loop updates the display buffer and sends data. For the ESP32, you can use the same SPI bus, but you need to set the clock frequency explicitly with SPI.begin(SCLK, MISO, MOSI, CS) and then SPI.setFrequency(1000000). The ESP32 has multiple timers, so use the ledc library to generate a 30 Hz PWM on EXTCOMIN. For the STM32, use the HAL library with SPI at 1 MHz, and a TIM timer configured for 30 Hz output compare.
The display buffer in RAM is 2,048 bytes (128 lines * 128 bits / 8 bits per byte). You can store the entire image or update only changed lines to save time. For example, if you only change a single character on a clock display, you can send only that line. The display supports partial updates, but you must send the entire line of 128 pixels, even if only one pixel changes. The command 0x01 with a line address writes only that line, while 0x00 writes all lines. The display also has a sleep mode command (0x04) that reduces power to 1 µA, but you need to wake it with a 0x01 or 0x00 command. After waking, wait 10 milliseconds for the display to stabilize before sending data.
One critical detail is the polarity of the pixel data. The display has a VCOM polarity that determines whether a 1 is black or white. You can set the polarity by sending a command 0x03 with a byte value, where the least significant bit sets the polarity. For example, 0x03 0x00 means a 1 pixel is black, and 0x03 0x01 means a 1 pixel is white. You need to set this at initialization, and it stays until you change it. If you don't set it, the display defaults to a random state, and your image might appear inverted. Also, the display has a DISP pin that you must hold high to enable the display. When DISP is low, the display is off and draws 1 µA. In your code, set DISP high at startup and keep it high.
For troubleshooting, common issues include: no image displayed, which is often due to incorrect SPI settings or missing EXTCOMIN signal. Check that your SPI clock is 1 MHz or less, because higher speeds cause data corruption. Also, verify that the CS pin is toggled correctly, because some libraries leave it low after a transaction. Use a logic analyzer to check the SPI signals. Another issue is image ghosting, which happens if the EXTCOMIN frequency is too low or too high. Stick to 30 Hz, and if you see flickering, adjust the duty cycle to exactly 50%. The display also has a temperature range of -20°C to 70°C, and at low temperatures, the update speed decreases, so you might need to increase the delay between commands to 10 microseconds.
In terms of mechanical integration, the display is 1.33 inches diagonal, with an active area of 26.86 mm by 26.86 mm, and a module size of 30.0 mm by 30.0 mm by 1.3 mm. It weighs about 5 grams, and the FPC cable is 20 mm long with a 0.5mm pitch connector. You can mount it in a 3D-printed enclosure or use adhesive tape to attach it to a PCB. The display is sensitive to static electricity, so handle it with an ESD wrist strap. The glass is 0.5 mm thick, so it's fragile, and you should avoid bending the FPC more than 90 degrees.
For advanced driving, you can use the display in a daisy-chain configuration with multiple displays, because each display has a chip select pin. However, the SPI bus can only handle one display at a time, so you need separate CS pins. The display also supports a "write only" mode where you can send data without waiting for a response, but you must ensure that the previous command completed. The datasheet specifies a maximum of 1 MHz for SPI, but some users report stable operation at 2 MHz with short cables. Test your setup with a known pattern, like a checkerboard, to verify timing.
Here is a reference table for the pinout of the 1.33 inch Sharp Memory TFT display:
| Pin Number | Name | Function | Notes |
|---|---|---|---|
| 1 | CS | Chip Select | Active low, enable SPI |
| 2 | SCLK | Serial Clock | 1 MHz max, rising edge |
| 3 | MOSI | Master Out Slave In | Data input |
| 4 | VDD | Power Supply | 3.0V to 3.6V, typical 3.3V |
| 5 | VSS | Ground | 0V |
| 6 | EXTCOMIN | External COM Inversion | 30 Hz square wave, 50% duty |
| 7 | DISP | Display On/Off | High for on, low for off |
| 8 | LED | Front Light | Optional, not used in reflective mode |
| 9 | NC | No Connect | Leave floating |
| 10 | NC | No Connect | Leave floating |
| 11 | NC | No Connect | Leave floating |
| 12 | NC | No Connect | Leave floating |
| 13 | NC | No Connect | Leave floating |
| 14 | NC | No Connect | Leave floating |
For the SPI command set, here is a table of the essential commands:
| Command | Byte Value | Description | Data to Follow |
|---|---|---|---|
| Write Line | 0x01 | Write a single line | 8-bit line address, then 128 bits of pixel data |
| Write All Lines | 0x00 | Write all 128 lines | 128 lines of 128 bits each, total 2048 bytes |
| Set VCOM Polarity | 0x03 | Set pixel polarity | 1 byte: 0x00 for black=1, 0x01 for white=1 |
| Sleep | 0x04 | Enter low-power mode | None |
| Wake | 0x01 or 0x00 | Exit sleep mode | Same as write command, but with dummy data |
When you send the Write All Lines command, you must send exactly 16,384 bits (2,048 bytes) of pixel data. Each byte represents 8 pixels horizontally, with the MSB being the leftmost pixel. For example, to draw a vertical line at column 0, you send 0x80 for each line. The display updates line by line from top to bottom, and you cannot interrupt the data stream. If you send fewer bytes, the display will show partial data. The datasheet specifies that the CS pin must be held low during the entire command and data transfer, and then brought high for at least 1 microsecond before the next command. This is critical for reliable operation.
For the EXTCOMIN signal, you can generate it using a 555 timer or a dedicated oscillator, but a microcontroller timer is more flexible. The frequency should be within 1 Hz to 60 Hz, but 30 Hz is standard. If you use a frequency lower than 1 Hz, the display will show image retention after a few minutes. If you use a frequency higher than 60 Hz, the display will flicker. The duty cycle must be 50% to avoid DC bias, and the waveform should be a square wave with a rise time of less than 1 microsecond. On an Arduino, you can use the following code to generate a 30 Hz signal on pin 9 using Timer1: set OCR1A to 26666 for a 16 MHz clock with a prescaler of 1024, and toggle the pin on compare match. For the ESP32, use ledcSetup(0, 30, 8) and ledcAttachPin(EXTCOMIN_PIN, 0) to generate a 30 Hz PWM with 50% duty.
One practical application is a battery-powered temperature display. Use a DS18B20 sensor, read the temperature every 10 seconds, and update the display only when the temperature changes. This reduces average power to under 10 µA, allowing a CR2032 coin cell to last for months. The display's memory-in-pixel technology means you don't need to refresh the image, so the microcontroller can sleep between updates. To do this, set the display to sleep mode (0x04) after each update, and wake it with a write command. The wake time is 10 milliseconds, so factor that into your sleep cycle. The display also has a built-in temperature compensation circuit, but it's not user-accessible, so you don't need to adjust for temperature changes.
Another detail is the display's response time. The datasheet specifies a typical update time of 30 milliseconds for a full frame, but this includes the internal settling time. In practice, you can send data at 1 MHz, and the display will update within 50 milliseconds. For partial updates, the response time is proportional to the number of lines updated. For example, updating a single line takes about 1 millisecond. This makes the display suitable for real-time data like a clock, where you update the seconds digit every second. However, the display is not suitable for video because the update rate is too slow.
In terms of reliability, the display has a rated lifetime of 50