# Adafruit Sharp Memory Display Breakout

## Overview

![](https://cdn-learn.adafruit.com/assets/assets/000/009/082/medium800/lcds___displays_1393disp7_LRG.jpg?1396882177)

The 1.3" SHARP Memory LCD display is a cross between an eInk (e-paper) display and an LCD. It has the ultra-low power usage of eInk and the fast-refresh rates of an LCD. This model has a matt silver background, and pixels show up as little mirrors for a silver-reflective display, a really beautiful and unique look. It does not have a backlight, but it is daylight readable. For dark/night reading you may need to illuminate the LCD area with external LEDs.   
  
The display is 3V powered and 3V logic, so we placed it on a fully assembled & tested breakout board with a 3V regulator and level shifting circuitry. The display slots into a ZIF socket on board and we use a piece of double-sided tape to adhere it onto one side. There are four mounting holes so you can easily attach it to a box.   
  
The display is 'write only' which means that it only needs 3 pins to send data. The downside of a write-only display is that the entire memory must be buffered by the microcontroller driver.

If you have one of the older 96x96 pixel versions, then 96x96 bits = 1,152 bytes. On an Arduino Uno/Leonardo that's half the RAM available and so it might not be possible to run this display with other RAM-heavy libraries like SD interfacing.

If you have one of the newer 168x144 pixel versions, then 168x144 bits = 3,024 bytes.  **That won't fit on an Arduino Uno or Leonardo!** You must use a chip with more RAM like a Metro or Feather M0 or ESP8266.  
  
The Sharp Memory Display breakout board ships with optional headers for use in a breadboard.

![](https://cdn-learn.adafruit.com/assets/assets/000/009/081/medium800/lcds___displays_2013_06_15_IMG_1911-1024.jpg?1396882157)

# Adafruit Sharp Memory Display Breakout

## Assembly

The display and support circuitry come pre-assembled and fully tested on a handy breakout board. For use in a breadboard, you will want to install the included 0.1" header strip:

# Installing the Header:
## Position the header
Trim the header to length if necessary and place it long pins down in your breadboard.![lcds___displays_2013_06_15_IMG_1917-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/073/medium640/lcds___displays_2013_06_15_IMG_1917-1024.jpg?1396882060)

![lcds___displays_2013_05_02_IMG_1741-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/085/medium640/lcds___displays_2013_05_02_IMG_1741-1024.jpg?1396882214)

## Position the display
Place the Sharp Memory Display over the pins on the breadboard.![lcds___displays_2013_06_15_IMG_1918-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/074/medium640/lcds___displays_2013_06_15_IMG_1918-1024.jpg?1396882075)

## Solder!
Solder each pin to assure good electrical conductivity.![lcds___displays_2013_06_15_IMG_1919-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/075/medium640/lcds___displays_2013_06_15_IMG_1919-1024.jpg?1396882090)

![lcds___displays_2013_06_15_IMG_1928-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/076/medium640/lcds___displays_2013_06_15_IMG_1928-1024.jpg?1396882102)

![lcds___displays_2013_06_15_IMG_1932-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/077/medium640/lcds___displays_2013_06_15_IMG_1932-1024.jpg?1396882115)

## Remove the Protective Film
After soldering is complete. Gently peel the film from the display. ![lcds___displays_2013_06_15_IMG_1930-1024.jpg](https://cdn-learn.adafruit.com/assets/assets/000/009/078/medium640/lcds___displays_2013_06_15_IMG_1930-1024.jpg?1396882131)

# Adafruit Sharp Memory Display Breakout

## Arduino Wiring

Danger: 

# Wiring to the Arduino:

This display can be driven with only 3 pins. Any pins can be used. The wiring we show here uses pins 10, 11 and 13 for compatibility with the library example code.

- **Microcontroller GND ** to ** LCD Gnd**  
- **Microcontroller 5V ** to **LCD Vin**
- **Microcontroller D13 ** to **LCD Clk**
- **Microcontroller D11 ** to **LCD DI**
- **Microcontroller D10 ** to **LCD CS**

![adafruit_products_arduino-wiring_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/083/335/medium640/adafruit_products_arduino-wiring_bb.jpg?1572557675)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/083/343/original/arduino-wiring.fzz?1572560338)
The other wires are optional, and connect directly to the Memory Display for more advanced uses. Check the raw display datasheet (in the downloads area) for details.

# Adafruit Sharp Memory Display Breakout

## Arduino Programming

# Download the Libraries

To use the Sharp Memory Display with your Arduino, you will need to download and install 2 libraries:

- [Sharp Memory Display Library](https://github.com/adafruit/Adafruit_SHARP_Memory_Display "Link: https://github.com/adafruit/Adafruit\_SHARP\_Memory\_Display")
- [Adafruit GFX Library](https://github.com/adafruit/Adafruit-GFX-Library "Link: https://github.com/adafruit/Adafruit-GFX-Library")
- [Adafruit BusIO Library](https://github.com/adafruit/Adafruit_BusIO)

For details on how to install libraries, see this guide: [All About Arduino Libraries](http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use).

# Run the Example Code

Once your libraries are installed, open the Arduino IDE and select:

> **File-\>Examples-\>Adafruit\_SHARP\_Memory\_Display-\>sharpmemtest**

Upload the example code to your Arduino and you should see the test graphics drawn on the screen.

http://www.youtube.com/watch?feature=player_embedded&v=nQLFWlcsdi4

## Programming GFX Graphics
The Sharp Memory Display is part of the growing family of Adafruit graphical displays that use the Adafruit GFX Library. This library lets you use a common set of graphical drawing functions on a whole variety of displays including.LED matrices, OLEDs, TFT LCDs, eInk and the Sharp Memory Display!  
  
For more details about programming with GFX, see our [Adafruit GFX Graphics Library Guide](http://learn.adafruit.com/adafruit-gfx-graphics-library). ![](https://cdn-learn.adafruit.com/assets/assets/000/009/084/medium800/lcds___displays_1393disp7_MED.jpg?1396882206)

# Adafruit Sharp Memory Display Breakout

## 2.7" Display Bad Apple Example

Warning: 

The Bad Apple video example was written for the 2.7" Sharp Display. This is a port of [ESP32\_BadApple](https://github.com/hackffm/ESP32_BadApple) which as the name implies, was plays the Bad Apple video and was written to run on the ESP32 and OLED displays. You'll want to start by downloading and unzipping the example files first:

[Download Example Files](https://github.com/adafruit/Adafruit_Learning_System_Guides/tree/master/SHARP_BadApple)
## Uploading the Video

It's easiest to start with uploading the video file first. The video data is kept in flash memory, so the easiest way to put it in there is to install CircuitPython briefly just to copy the file over before uploading the Arduino code. Fortunately, Installing CircuitPython is really easy. If you are not sure how, you can check out our [Welcome to CircuitPython guide](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython).

After it finished uploading, and with the Circuit Playground board connected over USB, it should appear on your computer as a flash drive called **CIRCUITPY**.

![adafruit_products_CIRCUITPY.png](https://cdn-learn.adafruit.com/assets/assets/000/094/216/medium640/adafruit_products_CIRCUITPY.png?1597882694)

You can find the file inside the **data** folder named **video.hs**.

![adafruit_products_video_location.png](https://cdn-learn.adafruit.com/assets/assets/000/094/217/medium640/adafruit_products_video_location.png?1597883221)

Go ahead and copy the video file over to the root of your **CIRCUITPY** drive. That's it, it's time to move over to arduino.

![adafruit_products_circuitpy_root.png](https://cdn-learn.adafruit.com/assets/assets/000/094/218/medium640/adafruit_products_circuitpy_root.png?1597883575)

## Additional Libraries

We'll assume you've already installed the libraries mentioned on the Arduino Programming page. There are a few additional libraries required to run the example:

### Adafruit Zero DMA

This is used by the Graphics Library if you choose to use DMA

![](https://cdn-learn.adafruit.com/assets/assets/000/094/219/medium800/adafruit_products_zeroDMA_lib.jpg?1597884517)

### Adafruit SPIFlash

This will let you read/write to the onboard FLASH memory with super-fast QSPI support

![](https://cdn-learn.adafruit.com/assets/assets/000/094/220/medium800/adafruit_products_SPIFlash_lib.jpg?1597884528)

### SdFat (Adafruit Fork)

The Adafruit fork of the really excellent SD card library that gives a lot more capability than the default SD library

![](https://cdn-learn.adafruit.com/assets/assets/000/094/221/medium800/adafruit_products_SDFAT_-_Adafruit_Fork.png?1597884540)

## Open in Arduino

Go ahead and open up the **SHARP\_BadApple.ino** file up in Arduino. There's only one small change we may need to make. Go ahead and locate the following line of code:

```cpp
#define SHARP_SS   A5
```

If your Chip Select line is connected differently, you may to change the value of `SHARP_SS`. That's the only change. After that, go ahead and upload it to your board. You should see an animation similar to the following:

![](https://cdn-learn.adafruit.com/assets/assets/000/094/223/medium800thumb/adafruit_products_4694-04.jpg?1597885443)

# Adafruit Sharp Memory Display Breakout

## CircuitPython displayio Setup

## CircuitPython Installation

First make sure you are running the [latest version of Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython) for your board, and that `sharpdisplay` is in its supported modules list.

Warning: 

## Libraries

Next you'll need to install the necessary libraries to use the hardware--carefully follow the steps to find and install these libraries from [Adafruit's CircuitPython library bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle/releases).  Our CircuitPython starter guide has [a great page on how to install the library bundle](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries).

[Download latest Library Bundle](https://circuitpython.org/libraries)
There are many libraries in the bundle that enhance displayio, but the two we need for the example code are

- **adafruit\_display\_text** - to show text and labels
- **adafruit\_bitmap\_font** - to load fonts from **CIRCUITPY** for better typography than the "built in" font  

Before continuing make sure your board's lib folder or root filesystem has the **adafruit\_display\_text** and **adafruit\_bitmap\_font** folders copied over.

![adafruit_products_Screenshot_2020-08-14_11-16-34.png](https://cdn-learn.adafruit.com/assets/assets/000/094/068/medium640/adafruit_products_Screenshot_2020-08-14_11-16-34.png?1597421822)

# Adafruit Sharp Memory Display Breakout

## CircuitPython displayio Usage

Warning: 

It's easy to use the Sharp Memory Display with CircuitPython and the [Adafruit CircuitPython SharpMemoryDisplay](https://github.com/adafruit/Adafruit_CircuitPython_SharpMemoryDisplay) module. This module allows you to easily write Python code to control the display.

Check the [support matrix](https://circuitpython.readthedocs.io/en/latest/shared-bindings/support_matrix.html) for your board to see whether it supports the `sharpdisplay` module.

To demonstrate the usage, we'll initialize the library and the Python REPL will be displayed on it. You can type these lines in directly or put them in **code.py.**

# Initialization

First, import required modules and release the existing display (if any).

```python
import board
import displayio
import framebufferio
import sharpdisplay
        
# Release the existing display, if any
displayio.release_displays()
```

Next, create the display using the appropriate **SPI bus** , **Chip Select (CS) Pin**, **width** , and **height.** The **baudrate** can also be set, though the default value of 2MHz should work with all Sharp Memory Displays. Make sure to use the right pin names as you have wired up to your board!  If you use a nonstandard SPI bus, construct it with `busio.SPI` instead of using `board.SPI()`.

```python
bus = board.SPI()
chip_select_pin = board.D6
# Select JUST ONE of the following lines:
# For the 400x240 display (can only be operated at 2MHz)
framebuffer = sharpdisplay.SharpMemoryFramebuffer(bus, chip_select_pin, 400, 240)
# For the 144x168 display (can be operated at up to 8MHz)
#framebuffer = sharpdisplay.SharpMemoryFramebuffer(bus, chip_select_pin, width=144, height=168, baudrate=8000000)
```

The last thing to do before you can use displayio routines is to connect the framebuffer as a display:

```python
display = framebufferio.FramebufferDisplay(framebuffer)
```

If you are doing this interactively at the Python REPL, you will now see the REPL mirrored onto the Sharp Memory Display.

![](https://cdn-learn.adafruit.com/assets/assets/000/094/041/medium800/adafruit_products_IMG_20200805_161440.jpg?1597177702)

# Drawing

The SharpMemoryDisplay module supports all the methods for drawing that DisplayIO supports: Text, bitmaps, shapes, etc. For instance, if you wanted to display a label using the built-in terminal font, you would use something like the following:

```python
from adafruit_display_text.label import Label
from terminalio import FONT
label = Label(font=FONT, text="BLACK\nLIVES\nMATTER", x=120, y=120, scale=4, line_spacing=1.2)
display.root_group = label
```

![](https://cdn-learn.adafruit.com/assets/assets/000/094/042/medium800/adafruit_products_IMG_20200805_210308.jpg?1597177725)

We cover CircuitPython displayio more in depth in its own guide, so now that you've got the display going, [learn more about CircuitPython Display Support Using displayio](https://learn.adafruit.com/circuitpython-display-support-using-displayio) to get the most out of it.

# Adafruit Sharp Memory Display Breakout

## Circuitpython displayio Example

This example displays the names of just some of the Black people injured or killed by police brutality in the United States. For more information about Adafruit's response to racial injustice, visit our dedicated [Black Lives Matter](https://www.adafruit.com/blacklivesmatter) page.

This particular example is designed to use the Adafruit 2.7" SHARP Memory Display.

## Installing Project Code

To use with CircuitPython, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script.

Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **CircuitPython\_SharpDisplay\_Displayio/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive.

Your **CIRCUITPY** drive should now look similar to the following image:

![CIRCUITPY](https://adafruit.github.io/Adafruit_Learning_System_Guides/CircuitPython_SharpDisplay_Displayio.png )

https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/CircuitPython_SharpDisplay_Displayio/code.py

# Adafruit Sharp Memory Display Breakout

## Python Wiring

It's easy to use the Sharp Memory Display with Python and the [Adafruit CircuitPython SharpMemoryDisplay](https://github.com/adafruit/Adafruit_CircuitPython_SharpMemoryDisplay) module.  This module allows you to easily write Python code to control the display.

We'll cover how to wire the display to your Raspberry Pi. First assemble your Sharp Display.

Since there's _dozens_ of Linux computers/boards you can use we will show wiring for Raspberry Pi. For other platforms, [please visit the guide for CircuitPython on Linux to see whether your platform is supported](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux). 

Connect the display as shown below to your Raspberry Pi.

- **Raspberry Pi GND ** to ** LCD Gnd**  
- **Raspberry Pi 3.3V ** to **LCD Vin**
- **Raspberry Pi SCK (GPIO 11) **to **LCD Clk**
- **Raspberry Pi MOSI (GPIO 10) **to **LCD DI**
- **Raspberry Pi GPIO 6 ** to **LCD CS**

![adafruit_products_python-wiring_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/083/341/medium640/adafruit_products_python-wiring_bb.jpg?1572560272)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/083/342/original/python-wiring.fzz?1572560302)
# Adafruit Sharp Memory Display Breakout

## Python Setup

You'll need to install the Adafruit\_Blinka library that provides the CircuitPython support in Python. This may also require enabling SPI on your platform and verifying you are running Python 3. [Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux)!

## Python Installation of SharpMemoryDisplay Library

Once that's done, from your command line run the following command:

- `pip3 install adafruit-circuitpython-sharpmemorydisplay`

If your default Python is version 3 you may need to run 'pip' instead. Just make sure you aren't trying to use CircuitPython on Python 2.x, it isn't supported!

If that complains about pip3 not being installed, then run this first to install it:

- `sudo apt-get install python3-pip`

## DejaVu TTF Font

Raspberry Pi usually comes with the DejaVu font already installed, but in case it didn't, you can run the following to install it:

- `sudo apt-get install fonts-dejavu`

This package was previously calls **ttf-dejavu** , so if you are running an older version of Raspberry Pi OS, it may be called that.

## Pillow Library

We also need PIL, the Python Imaging Library, to allow using text with custom fonts. There are several system libraries that PIL relies on, so installing via a package manager is the easiest way to bring in everything:

- `sudo apt-get install python3-pil`

That's it. You should be ready to go.

# Adafruit Sharp Memory Display Breakout

## Python Usage

It's easy to use the Sharp Memory Display with CircuitPython and the [Adafruit CircuitPython SharpMemoryDisplay](https://github.com/adafruit/Adafruit_CircuitPython_SharpMemoryDisplay) module. This module allows you to easily write Python code to control the display.

You can use this display with a computer that has GPIO and Python [thanks to Adafruit\_Blinka, our CircuitPython-for-Python compatibility library](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux).

To demonstrate the usage, we'll initialize the library and use Python code to control the display from the board's Python REPL.

Since we are running full CPython on our Linux/computer, we can take advantage of the powerful Pillow image drawing library to handle text, shapes, graphics, etc. [Pillow is a gold standard in image and graphics handling, you can read about all it can do here](https://pillow.readthedocs.io/en/stable/).

# Initialization

First need to initialize the SPI bus. To do that, run the following commands:

```python
import board
import busio
import digitalio
import adafruit_sharpmemorydisplay

spi = busio.SPI(board.SCK, MOSI=board.MOSI)
scs = digitalio.DigitalInOut(board.D6) # inverted chip select

display = adafruit_sharpmemorydisplay.SharpMemoryDisplay(spi, scs, 144, 168)
```

The last three parameters to the initializer are the pins connected to the display's **CS** line, **width** and **height**  in that order.  Again make sure to use the right pin names as you have wired up to your board!

# Example Code
https://github.com/adafruit/Adafruit_CircuitPython_SharpMemoryDisplay/blob/main/examples/sharpmemorydisplay_pillow_demo.py

Let's take a look at the sections of code one by one. We start by importing the `board` so that we can access the pin definitions, `busio` so we can initialize SPI, `digitalio`, several `PIL` modules for Image Drawing, and the `adafruit_sharpmemorydisplay` driver.

```python
import board
import busio
import digitalio
from PIL import Image, ImageDraw, ImageFont
import adafruit_sharpmemorydisplay
```

To make it easy to keep track of which numbers represent which colors, we define some colors near the top.

```python
# Colors
BLACK = 0
WHITE = 255
```

In order to make it easy to change display sizes, we'll define a few variables in one spot here. We have the border size and font size, which we will explain a little further below.

```python
BORDER = 5
FONTSIZE = 10
```

Next we set the SPI object to the board's SPI with `busio.SPI()`. We also define some Pins that will be used for the display and initialize the display. See the initialization section above for more details. By default, the initializer for the 144x168 display is uncommented because that's what we currently have in the store. If you had the 96x96 pixel version of the screen, you could use the other initializer instead.

```python
spi = busio.SPI(board.SCK, MOSI=board.MOSI)
dc = digitalio.DigitalInOut(board.D6) # data/command
cs = digitalio.DigitalInOut(board.CE0) # Chip select
reset = digitalio.DigitalInOut(board.D5) # reset

#display = adafruit_sharpmemorydisplay.SharpMemoryDisplay(spi, scs, 96, 96)
display = adafruit_sharpmemorydisplay.SharpMemoryDisplay(spi, scs, 144, 168)
```

Next we clear the display in case it was initialized with any random artifact data.

```python
# Clear display.
display.fill(0)
display.show()
```

Next, we need to initialize PIL to create a blank image to draw on. Think of it as a virtual canvas. Since this is a monochrome display, we set it up for 1-bit color, meaning a pixel is either white or black. We can make use of the display's width and height properties as well.

```python
# Create blank image for drawing.
# Make sure to create image with mode '1' for 1-bit color.
image = Image.new('1', (display.width, display.height))

# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
```

Now we start the actual drawing. Here we are telling it we want to draw a rectangle from `(0,0)`, which is the upper left, to the full width and height of the display. We want it both filled in and having an outline of black, so we pass `BLACK` for both values.

```python
# Draw a black background
draw.rectangle((0, 0, display.width, display.height), outline=BLACK, fill=BLACK)
```

If we ran the code now, it would still show a blank display because we haven't told python to use our virtual canvas yet. You can skip to the end if you would like to see how to do that. This is what our canvas currently looks like in memory.

![](https://cdn-learn.adafruit.com/assets/assets/000/083/350/medium800/adafruit_products_pillow_large_rect.jpeg?1572563669)

Next we will create a smaller white rectangle. The easiest way to do this is to draw another rectangle a little smaller than the full screen with no fill or outline and place it in a specific location. In this case, we will create a rectangle that is 5 pixels smaller on each side. This is where the **BORDER** variable comes into use. It makes calculating the size of the second rectangle much easier. We want the starting coordinate, which consists of the first two parameters, to be our BORDER value. Then for the next two parameters, which are our ending coordinates, we want to subtract our border value from the width and height. Also, because this is a zero-based coordinate system, we also need to subtract 1 from each number. Again, we set the `fill` and `outline` to `WHITE`.

```python
# Draw a smaller inner rectangle
draw.rectangle((BORDER, BORDER, display.width - BORDER - 1, display.height - BORDER - 1),
               outline=WHITE, fill=WHITE)
```

Here's what our virtual canvas looks like in memory.

![](https://cdn-learn.adafruit.com/assets/assets/000/083/351/medium800/adafruit_products_pillow_small_rect.jpeg?1572563686)

Now drawing text with PIL is pretty straightforward. First we start by setting the font to the default system text. After that we define our text and get the size of the text. We're grabbing the size that it would render at so that we can calculate the center position. Finally, we take the font size and screen size to calculate the position we want to draw the text at and it appears in the center of the screen.

```python
# Load a TTF font.
font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', FONTSIZE)

# Draw Some Text
text = "Hello World!"
(font_width, font_height) = font.getsize(text)
draw.text((display.width//2 - font_width//2, display.height//2 - font_height//2),
          text, font=font, fill=BLACK)
```

Finally, we need to display our virtual canvas to the display and we do that with 2 commands. First we set the image to the screen, then we tell it to show the image.

```python
# Display image
display.image(image)
display.show()
```

Warning: 

Here's what the final output should look like.

![](https://cdn-learn.adafruit.com/assets/assets/000/083/352/medium800/adafruit_products_pillow_hello_world.jpeg?1572563697)

# Adafruit Sharp Memory Display Breakout

## CircuitPython Docs

# Adafruit Sharp Memory Display Breakout

## Downloads and Links

## Libraries:

- [Sharp Memory Display Library](https://github.com/adafruit/Adafruit_SHARP_Memory_Display "Link: https://github.com/adafruit/Adafruit\_SHARP\_Memory\_Display")
- [Adafruit GFX Library](https://github.com/adafruit/Adafruit-GFX-Library "Link: https://github.com/adafruit/Adafruit-GFX-Library")

## Files

- [Datasheet for the LS013B4DN04 LCD Module](http://www.adafruit.com/datasheets/LS013B4DN04-3V_FPC-204284.pdf "Link: http://www.adafruit.com/datasheets/LS013B4DN04-3V\_FPC-204284.pdf")
- [Datasheet for the LS027B7DH01 LCD Module](https://cdn-learn.adafruit.com/assets/assets/000/094/215/original/LS027B7DH01_Rev_Jun_2010.pdf?1597872422)
- [Fritzing object in Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library)
- [EagleCAD PCB files on GitHub](https://github.com/adafruit/Adafruit-Sharp-Memory-Display)

## Library Reference

- [Adafruit GFX Library](http://learn.adafruit.com/adafruit-gfx-graphics-library/overview "Link: http://learn.adafruit.com/adafruit-gfx-graphics-library/overview")

[LS013B7DH05 Datasheet](https://cdn-learn.adafruit.com/assets/assets/000/068/725/original/LS013B7DH05.pdf?1546719395)
![](https://cdn-learn.adafruit.com/assets/assets/000/009/083/medium800/lcds___displays_1393disp4_LRG.jpg?1396882192)

# Schematic & Fabrication Print 2.7" Display
![](https://cdn-learn.adafruit.com/assets/assets/000/094/077/medium800/adafruit_products_2-7in_sharp_memory_display_sch.png?1597425104)

![](https://cdn-learn.adafruit.com/assets/assets/000/094/078/medium800/adafruit_products_2-7in_sharp_memory_display_fab_print.png?1597425115)

# Schematic & Fabrication Print 1.3" Display
![](https://cdn-learn.adafruit.com/assets/assets/000/017/716/medium800/lcds___displays_sharpschem.png?1404230603)

![](https://cdn-learn.adafruit.com/assets/assets/000/017/717/medium800/lcds___displays_sharpprint.png?1404230604)


## Related Guides

- [DIY Desktop Calculator with CircuitPython ](https://learn.adafruit.com/diy-rpn-desktop-calculator-with-circuitpython.md)
- [Adafruit New York and NYC DOE vendor information ](https://learn.adafruit.com/educational-orders-for-educators-based-in-new-york.md)
- [Adafruit Metro RP2350](https://learn.adafruit.com/adafruit-metro-rp2350.md)
- [Adafruit nRF52 Pro Feather with Mynewt](https://learn.adafruit.com/adafruit-nrf52-pro-feather.md)
- [Adafruit I2C to 8 Channel Solenoid Driver](https://learn.adafruit.com/adafruit-i2c-to-8-channel-solenoid-driver.md)
- [Adafruit DS2484 I2C to 1-Wire Bus Adapter Breakout](https://learn.adafruit.com/adafruit-ds2484-i2c-to-1-wire-bus-adapter-breakout.md)
- [Bendable Sound Reactive Lamp with WLED](https://learn.adafruit.com/bendable-sound-reactive-lamp-with-wled.md)
- [Adafruit QT 5V to 3V Shifter Breakout](https://learn.adafruit.com/adafruit-qt-5v-to-3v-shifter-breakout.md)
- [Pixie - the 3W Chainable LED Pixel](https://learn.adafruit.com/pixie-3-watt-smart-chainable-led-pixels.md)
- [Dragon Kite Poi with Animated Lights and WLED](https://learn.adafruit.com/dragon-kite-poi-with-animated-lights-and-wled.md)
- [Adafruit LSM9DS0 Accelerometer + Gyro + Magnetometer 9-DOF Breakouts](https://learn.adafruit.com/adafruit-lsm9ds0-accelerometer-gyro-magnetometer-9-dof-breakouts.md)
- [Adafruit Wii Nunchuck Breakout Adapter](https://learn.adafruit.com/adafruit-wii-nunchuck-breakout-adapter.md)
- [Adafruit ItsyBitsy nRF52840 Express](https://learn.adafruit.com/adafruit-itsybitsy-nrf52840-express.md)
- [Adafruit bq25185 USB / DC / Solar Lithium Ion/Polymer Charger](https://learn.adafruit.com/adafruit-bq25185-usb-dc-solar-lithium-ion-polymer-charger.md)
- [PyPortal Adafruit Quote Book](https://learn.adafruit.com/pyportal-adafruit-quote-board.md)