# Adafruit eInk Display Breakouts and FeatherWings

## Overview

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/071/124/medium800/adafruit_products_2.13%22_eInk_Display_Product_Image.jpg?1550098760)

Easy e-paper finally comes to microcontrollers, with these breakouts, shields and friends that are designed to make it a breeze to add a tri-color eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static' displays - that means the image stays on the display even when power is completely disconnected. The image is also high contrast and very daylight readable. It really does look just like printed paper!

We've liked these displays for a long time, but they were never designed for makers to use. Finally, we decided to make our own!

![](https://cdn-learn.adafruit.com/assets/assets/000/057/627/medium800/adafruit_products_3625_iso_ORIG_2018_07.jpg?1531705761)

We have multiple tri-color displays. They have black and red ink pixels and a white-ish background. Using our Arduino library, you can create a 'frame buffer' with what pixels you want to have activated and then write that out to the display. Most simple breakouts leave it at that. But if you do the math, using even the smallest 1.54" display: 152 x 152 pixels x 2 colors = 5.7 KBytes. Which won't fit into many microcontroller memories. Heck, even if you do have 32KB of RAM, why waste 6KB?

**So we did you a favor and tossed a small SRAM chip on the back.** This chip shares the SPI port the eInk display uses, so you only need one extra pin. And, no more frame-buffering! **You can use the SRAM to set up whatever you want to display, then shuffle data from SRAM to eInk when you're ready. [The library we wrote does all the work for you](https://github.com/adafruit/Adafruit_EPD)**[, you can just interface with it as if it were an Adafruit\_GFX compatible display](https://github.com/adafruit/Adafruit_EPD).

![](https://cdn-learn.adafruit.com/assets/assets/000/074/555/medium800/adafruit_products_4224-08.jpg?1555474121)

On the EInk Friends and Breakouts, for ultra-low power usages, the onboard 3.3V regulator has the Enable pin brought out so you can shut down the power to the SRAM, MicroSD and display.

![](https://cdn-learn.adafruit.com/assets/assets/000/086/032/medium800/adafruit_products_Feather_eInk_Friend_Display_Attached.jpg?1576764837)

On the Breakouts and Shields, We even tossed on a MicroSD socket so you can store images, text files, whatever you like to display. Everything is 3 or 5V logic safe so you can use it with any and all microcontrollers.

![](https://cdn-learn.adafruit.com/assets/assets/000/074/554/medium800/adafruit_products_4229-05.jpg?1555474095)

# Adafruit eInk Display Breakouts and FeatherWings

## Pinouts

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/070/285/medium800/adafruit_products_213top.jpg?1548875774)

This e-Paper display uses SPI to receive image data. Since the display is SPI, it was easy to add two more SPI devices to share the bus - an SPI SRAM chip and SPI-driven SD card holder. There's quite a few pins and a variety of possible combinations for control depending on your needs

![](https://cdn-learn.adafruit.com/assets/assets/000/075/679/medium800/adafruit_products_4197.png?1557864475)

![](https://cdn-learn.adafruit.com/assets/assets/000/075/703/medium800/adafruit_products_Adafruit_154_eInk_Pinouts.png?1557944507)

Info: 

## eInk Breakout Friend

Connect a bare eInk display to this breakout to use it!

![](https://cdn-learn.adafruit.com/assets/assets/000/077/181/medium800/adafruit_products_eInk_Breakout_Friend.png?1560962607)

# Power Pins
![](https://cdn-learn.adafruit.com/assets/assets/000/057/632/medium800/adafruit_products_powerpins.jpg?1531705942)

- **3-5V / Vin** - this is the power pin, connect to 3-5VDC - it has reverse polarity protection but try to wire it right!
- **3.3V** out - this is the 3.3V output from the onboard regulator, you can 'borrow' about 100mA if you need to power some other 3.3V logic devices
- **GND** - this is the power and signal ground pin
- **ENA** ble - This pin is all the way on the right. It is connected to the enable pin on the onboard regulator that powers everything. If you want to _really_ have the lowest possible power draw, pull this pin low! Note that if you do so you will cut power to the eInk display but also the SPI RAM (thus erasing it) and the SD card (which means you'll have to re-initialize it when you re-power

# Data Control Pins
![](https://cdn-learn.adafruit.com/assets/assets/000/057/630/medium800/adafruit_products_datapins.jpg?1531705928)

- **SCK** - this is the SPI clock input pin, required for e-Ink, SRAM and SD card
- **MISO** - this is the SPI Microcontroller In Serial Out pin, its used for the SD card and SRAM. It isn't used for the e-Ink display which is write-only, however you'll likely be using the SRAM to buffer the display so connect this one too!
- **MOSI** - this is the SPI Microcontroller Out Serial In pin, it is used to send data from the microcontroller to the SD card, SRAM and e-Ink display
- **ECS** - this is the **E** -Ink **C** hip **S** elect, required for controlling the display
- **D/C** - this is the e-Ink **D** ata/ **C** ommand pin, required for controlling the display
- **SRCS** - this is the **S**** R **AM** C **hip** S**elect, required for communicating with the onboard RAM chip.
- **SDCS** - this is the **SD** card **C** hip **S** elect, required for communicating with the onboard SD card holder. You can leave this disconnected if you aren't going to access SD cards
- **RST** - this is the E-Ink **R** e **S** e **T** pin, you may be able to share this with your microcontroller reset pin but if you can, connect it to a digital pin.
- **BUSY** - this is the e-Ink busy detect pin, and is optional if you don't want to connect the pin (in which case the code will just wait an approximate number of seconds)

# FeatherWing Connections
![](https://cdn-learn.adafruit.com/assets/assets/000/072/066/medium800/adafruit_products_pinouts.jpg?1551335317)

![](https://cdn-learn.adafruit.com/assets/assets/000/086/034/medium800/adafruit_products_Feather_eInk_Friend_pinouts.png?1576765769)

The FeatherWing eInk Display and eInk Feather Friend are a little more compact but have just about the same pins as the breakout

- **SPI MOSI/MISO/SCK** are on the FeatherWing SPI connection pads

SD CS, SRAM CS, EINK CS and DC are in order after the two I2C pins. The numbers of the pins these correspond to will differ from board to board. However, on 32u4/328p/M0/M4/nRF52840 and many other boards you will see the following connections

- **SD CS** to Pin **D5**
- **SRAM CS** to Pin **D6**
- **EINK CS** to Pin **D9**
- **EINK DC** to Pin **D10**

If you do not plan to use the SD card, you can cut the trace to SD CS. Likewise for SRAM CS.

The **Reset** pin for the E-Ink display is connected to an auto-reset circuit and also to the Feather Reset pin, so it will reset when you press the reset button.

The **Busy** pin is available on a breakout pad, you can solder it to a wire and connect to a pin if you need it - we figure most people will just use a fixed delay.

# Adafruit eInk Display Breakouts and FeatherWings

## Shield Pinouts

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/074/553/medium800/adafruit_products_4229-04.jpg?1555473379)

The 2.7" EInk Shield is a little special in that the pins are fixed, so we'll document that here.

# Power Pins

- **5V** - this pin on the Arduino is used to generate the 3V logic level for the EInk chip, level shifter and boost converter.
- **GND** - connected for power and logic reference
- **IORef** - this pin is connected to the level shifter and pullups. On modern Arduino boards it is connected to the logic level of the board (3V or 5V)

# Data Pins

- **SCK, MISO, MOSI** - The 3 SPI logic pins are connected through the 2x3 socket header which is compatible with any Arduino board. If you have an Arduino board without the 2x3 headers, you can cut the jumpers and connect the solder jumper traces to D13, D12 and D11 respectively.
- **ECS** (EInk Chip Select) - this is connected to **D10**
- **DC** (EInk Data/Command) - this is connected to **D9**
- **SCS** (SRAM Chip Select) - this is connected to **D8**
- **SDCS** (SD Card Chip Select) - this is connected to **D5**

The **BUSY** pin is not used on the 2.7" display (it doesn't do anything anyways)

The **RESET** pin is connected to the microcontroller reset pin, but is available on a pad labeled **EReset** if you want to toggle it yourself!

# Buttons

The 4 buttons on the front are connected through a resistor divider to **A3** you can use this function to determine what button was pressed:

```
int8_t readButtons(void) {
  uint16_t reading = analogRead(A3);
  //Serial.println(reading);

  if (reading > 600) {
    return 0; // no buttons pressed
  }
  if (reading > 400) {
    return 4; // button D pressed
  }
  if (reading > 250) {
    return 3; // button C pressed
  }
  if (reading > 125) {
    return 2; // button B pressed
  }
  return 1; // Button A pressed
}
```

Here's a simple test example for an Arduino with standard pin numbers:

```python
/***************************************************
  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.
  MIT license, all text above must be included in any redistribution
 ****************************************************/

#include "Adafruit_ThinkInk.h"

#define EPD_DC      9 // can be any pin, but required!
#define EPD_CS      10  // can be any pin, but required!
#define EPD_BUSY    -1  // can set to -1 to not use a pin (will wait a fixed delay)
#define SRAM_CS     8  // can set to -1 to not use a pin (uses a lot of RAM!)
#define EPD_RESET   -1  // can set to -1 and share with chip Reset (can't deep sleep)

// 2.7" Tricolor Featherwing or Breakout with IL91874 chipset
ThinkInk_270_Tricolor_C44 display(EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY);


void setup() {
  Serial.begin(115200);
  while (!Serial) { delay(10); }
  Serial.println("Adafruit EPD full update test in red/black/white");
  display.begin(THINKINK_TRICOLOR);
  display.setRotation(2);
}

void loop() {
  Serial.println("Banner demo");
  display.clearBuffer();
  display.setTextSize(3);
  display.setCursor((display.width() - 144)/2, (display.height() - 24)/2);
  display.setTextColor(EPD_BLACK);
  display.print("Tri");  
  display.setTextColor(EPD_RED);
  display.print("Color");  
  display.display();

  delay(15000);
  
  Serial.println("Color rectangle demo");
  display.clearBuffer();
  display.fillRect(display.width()/3, 0, display.width()/3, display.height(), EPD_BLACK);
  display.fillRect((display.width()*2)/3, 0, display.width()/3, display.height(), EPD_RED);
  display.display();

  delay(15000);
  
  Serial.println("Text demo");
  // large block of text
  display.clearBuffer();
  display.setTextSize(1);
  testdrawtext("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur adipiscing ante sed nibh tincidunt feugiat. Maecenas enim massa, fringilla sed malesuada et, malesuada sit amet turpis. Sed porttitor neque ut ante pretium vitae malesuada nunc bibendum. Nullam aliquet ultrices massa eu hendrerit. Ut sed nisi lorem. In vestibulum purus a tortor imperdiet posuere. ", EPD_BLACK);
  display.display();

  delay(15000);

  display.clearBuffer();
  for (int16_t i=0; i<display.width(); i+=4) {
    display.drawLine(0, 0, i, display.height()-1, EPD_BLACK);
  }

  for (int16_t i=0; i<display.height(); i+=4) {
    display.drawLine(display.width()-1, 0, 0, i, EPD_RED);
  }
  display.display();

  delay(15000);  
}


void testdrawtext(char *text, uint16_t color) {
  display.setCursor(0, 0);
  display.setTextColor(color);
  display.setTextWrap(true);
  display.print(text);
}
```

# Adafruit eInk Display Breakouts and FeatherWings

## Assembly

![](https://cdn-learn.adafruit.com/assets/assets/000/071/151/medium800/adafruit_products_3625-04.jpg?1550175621)

## Assembly
Cut the header down to length if necessary. It will be easier to solder if you insert it into a breadboard -  **long pins down**

![](https://cdn-learn.adafruit.com/assets/assets/000/071/150/medium800/adafruit_products_DSC_4034.jpg?1550175608)

## Add the E-Ink Display

 

Place the board over the pins so that the short pins poke through the top of the breakout pads

![adafruit_products_DSC_4035.jpg](https://cdn-learn.adafruit.com/assets/assets/000/071/152/medium640/adafruit_products_DSC_4035.jpg?1550175646)

## And Solder!

 

Be sure to solder all pins for reliable electrical contact.  
  
_(For tips on soldering, be sure to check out the _[_Guide to Excellent Soldering_](http://learn.adafruit.com/adafruit-guide-excellent-soldering)_)._

![adafruit_products_DSC_4036.jpg](https://cdn-learn.adafruit.com/assets/assets/000/071/153/medium640/adafruit_products_DSC_4036.jpg?1550175659)

![adafruit_products_DSC_4041.jpg](https://cdn-learn.adafruit.com/assets/assets/000/071/154/medium640/adafruit_products_DSC_4041.jpg?1550175694)

![adafruit_products_DSC_4043.jpg](https://cdn-learn.adafruit.com/assets/assets/000/071/156/medium640/adafruit_products_DSC_4043.jpg?1550176791)

OK, you're done!

![](https://cdn-learn.adafruit.com/assets/assets/000/071/155/medium800/adafruit_products_DSC_4044.jpg?1550176756)

# Adafruit eInk Display Breakouts and FeatherWings

## Usage & Expectations

![](https://cdn-learn.adafruit.com/assets/assets/000/057/633/medium800thumb/adafruit_products_ezgif-5-28d9bfb373.jpg?1531711106)

One thing to remember with these small e-Ink screens is that its _very slow_ compared to OLEDs, TFTs, or even 'memory displays'. **It will take may seconds to fully erase and replace an image**

There's also a recommended limit on refeshing - **you shouldn't refresh or change the display more than every 3 minutes (180 seconds)**.

You don't have to refresh often, but with tri-color displays, the larger red ink dots will slowly rise, turning the display pinkish instead of white background. **To keep the background color clear and pale, refresh once a day**

Danger: 

# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Setup

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

To use the display, you will need to [install the Adafruit\_EPD library (code on our github repository)](https://github.com/adafruit/Adafruit_EPD "Link: https://github.com/adafruit/Adafruit\_EPD"). It is available from the Arduino library manager so we recommend using that.

From the IDE open up the library manager...

![](https://cdn-learn.adafruit.com/assets/assets/000/096/249/medium800/adafruit_products_Manage_Libraries.png?1603397012)

And type in **adafruit EPD** to locate the library. Click **Install**

If you would like to draw bitmaps, do the same with **adafruit ImageReader** , click **Install**

Do the same to install the latest **adafruit GFX** library, click **Install**

![](https://cdn-learn.adafruit.com/assets/assets/000/096/250/medium800/adafruit_products_arduino_compatibles_adafruit-gfx-library-manager.png?1603397155)

If using an earlier version of the Arduino IDE (pre-1.8.10), locate and install **Adafruit\_BusIO** (newer versions handle this prerequisite automatically).

# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Code

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

Danger: 

# Wiring

Wiring up the display in SPI mode is pretty easy as there's not that many pins! We'll be using hardware SPI, but you can also use software SPI (any pins) later.

Info: 

![](https://cdn-learn.adafruit.com/assets/assets/000/057/698/medium800/adafruit_products_metrowiring_bb.png?1531930970)

Start by connecting the power pins

- **3-5V Vin** connects to the microcontroller board's **5V** or **3.3V** power supply pin
- **GND** connects to ground

### Required SPI Pins

These use the hardware SPI interface and is required so check your microcontroller board to see which pins are _hardware SPI_

- **CLK** connects to SPI clock. On Arduino Uno/Duemilanove/328-based, thats **Digital 13**. (For other Arduino-compatibles [See SPI Connections for more details](http://arduino.cc/en/Reference/SPI))
- **MISO** connects to SPI MISO. On Arduino Uno/Duemilanove/328-based, thats **Digital 12**. (For other Arduino-compatibles [See SPI Connections for more details](http://arduino.cc/en/Reference/SPI))
- **MOSI** connects to SPI MOSI. On Arduino Uno/Duemilanove/328-based, thats **Digital 11**. (For other Arduino-compatibles [See SPI Connections for more details](http://arduino.cc/en/Reference/SPI))

### Other Digital I/O Pins

These can be set in the sketch to any pins you like but to follow the exact example code we'll use the following:

- **ECS** connects to our e-Ink Chip Select pin. We'll be using **Digital 10** but you can later change this to any pin
- **D/C** connects to our e-Ink data/command select pin. We'll be using **Digital 9** but you can later change this pin too.
- **SRCS** connects to our SRAM Chip Select pin. We'll be using **Digital 8** but you can later change this to any pin
- **RST** connects to our e-Ink reset pin. We'll be using **Digital 5** but you can later change this pin too.
- **BUSY** connects to our e-Ink busy pin. We'll be using **Digital 3** but you can later change this pin too.

# FeatherWing Connection

FeatherWing usage is easy, simply plug your Feather into the Wing

![](https://cdn-learn.adafruit.com/assets/assets/000/072/067/medium800/adafruit_products_image.png?1551339570)

# Load First Demo

Open up **File→Examples→Adafruit\_EPD→EPDTest****  **

If you have the FeatherWing open up **File→Examples→Adafruit\_EPD→FeatherWingTest**

![](https://cdn-learn.adafruit.com/assets/assets/000/057/701/medium800/adafruit_products_epdtest.png?1531932556)

At the top of the sketch find the lines that look like:

```
/* Uncomment the following line if you are using 1.54" tricolor EPD */
Adafruit_IL0373 display(152, 152 ,EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY);
/* Uncomment the following line if you are using 2.13" tricolor EPD */
//Adafruit_IL0373 display(212, 104 ,EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY);
/* Uncomment the following line if you are using 2.7" tricolor EPD */
//Adafruit_IL91874 display(264, 176 ,EPD_DC, EPD_RESET, EPD_CS, SRAM_CS);
```

And uncomment the matching object for the screen chipset and resolution you will be using. Then upload to your microcontroller wired up to the display

You will see the display flash a bunch and then a set of black and red lines will appear like shown on the left.

 

If you see the lines, your wiring is good! If not, go back and check your wiring to make sure its correct. If you didn't use the default pins, change them in the sketch

![adafruit_products_lines.jpg](https://cdn-learn.adafruit.com/assets/assets/000/057/702/medium640/adafruit_products_lines.jpg?1531933699)

# Load Graphics Test Demo

Open up **File→Examples→Adafruit\_EPD→**** graphicstest** and upload to your microcontroller wired up to the display

If you're using a FeatherWing, use the pin definitions from the top of **FeatherWingTest** , for example:

`#ifdef ESP8266`  
`#define SD_CS 2`  
`#define SRAM_CS 16`  
`#define EPD_CS 0`  
`#define EPD_DC 15`  
`#endif`

and copy those into the top of the graphics test sketch

This time you will see the display going through a range of tests, from pixels, lines, text circles etc.

 

This shows all the different shapes and techniques you can use that come with the Adafruit GFX library! Unlike most e-paper displays, where you can only draw an image, the built in SRAM lets you have full control over what shows up on the eInk screen.

![adafruit_products_text.jpg](https://cdn-learn.adafruit.com/assets/assets/000/057/703/medium640/adafruit_products_text.jpg?1531934179)

Info: 

# Unnecessary Pins

Once you've gotten everything working you can experiment with removing the **RST** and **BUSY** pins. We recommend tying **RST** to your microcontroller's Reset line so the eInk display is reset when the microcontrollers is. The busy pin makes startup a little faster but we don't find it to be essential

You can set the code as below to remove control of those pins from the Adafruit\_EPD library:

```
#define EPD_RESET   -1 // can set to -1 and share with microcontroller Reset!
#define EPD_BUSY    -1 // can set to -1 to not use a pin (will wait a fixed delay)
```

Thus saving you two pins!

Note that the 2.7" Tri-color display works best if you have a reset pin, it really likes being reset before sending data, so we recommend keeping it.

# Adafruit eInk Display Breakouts and FeatherWings

## Drawing Bitmaps

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/057/704/medium800/adafruit_products_demo.jpg?1531934602)

Warning: 

Not only can you draw shapes but you can also load images from the SD card, perfect for static images!

The 1.54" display can show a max of 152x152 pixels. Lets use this Blinka bitmap as our demo:

![](https://cdn-learn.adafruit.com/assets/assets/000/057/705/medium800/adafruit_products_blinka.bmp?1531934796)

[Click here to download blinka.bmp](https://cdn-learn.adafruit.com/assets/assets/000/057/705/original/adafruit_products_blinka.bmp)
For the 2.13" display, use this image instead

![](https://cdn-learn.adafruit.com/assets/assets/000/072/112/medium800/adafruit_products_blinka.bmp?1551414996)

[2.13" Sized bitmap](https://cdn-learn.adafruit.com/assets/assets/000/072/112/original/adafruit_products_blinka.bmp)
Rename the file **blinka.bmp** and place into the base directory of a microSD card and insert it into the microSD socket in the breakout. 

One extra wire is required, for **SDCS** which is the SD card Chip Select. We'll connect that to pin #4 but you can use any pin.

![](https://cdn-learn.adafruit.com/assets/assets/000/057/706/medium800/adafruit_products_bitmapwiring.png?1531934944)

Plug the MicroSD card into the display. You may want to try the **SD library** examples before continuing, especially one that lists all the files on the SD card

Open the **file→examples→Adafruit\_ImageReader→EInkBreakouts**  example

Upload to the upload & you will see Blinka appear!

![](https://cdn-learn.adafruit.com/assets/assets/000/057/708/medium800thumb/adafruit_products_3625.jpg?1531935446)

# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Library Documentation

# Adafruit eInk Display Breakouts and FeatherWings

## Adafruit GFX Library

# Adafruit eInk Display Breakouts and FeatherWings

## CircuitPython Code

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

Danger: 

# CircuitPython Microcontroller Wiring

Using eInk displays with `displayio` is really easy. First, wire up your eInk breakout as shown below. All displays have the same pinout, so if your display differs from the one in the Fritzing diagram, you can wire it up the same way.

### Breakout Wiring
- **Feather 3V** to **display VIN**
- **Feather GND** to **display GND**
- **Feather SCK** to **display SCK**
- **Feather MOSI** to **display MOSI**
- **Feather D10** to **display D/C**
- **Feather D9** to **display ECS**
- **Feather D6** to **display BUSY**
- **Feather D5** to **display RST**

![](https://cdn-learn.adafruit.com/assets/assets/000/082/438/medium800/adafruit_products_epd_displayio_bb.jpg?1571163803)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/082/516/original/epd_displayio.fzz?1571419272)
### FeatherWing Wiring
![](https://cdn-learn.adafruit.com/assets/assets/000/082/518/medium800/adafruit_products_epd_featherwing_bb.jpg?1571419406)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/082/517/original/epd_featherwing.fzz?1571419295)
Warning: 

## CircuitPython eInk displayio Library Installation

To use displayio, you will need to install the appropriate library for your display. 

First make sure you are running the [latest version of Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython) for your board. You will need CircuitPython version 5.0 or later.

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).  Our introduction guide has [a great page on how to install the library bundle](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries) for both express and non-express boards.

You will need to copy the appropriate displayio driver from the bundle **lib** folder to a **lib** folder on your **CIRCUITPY** drive. The displayio driver contains the initialization codes specific to your display that are needed to for it to work. Since there is more than one driver, you will need to copy the correct file over. Here is a list of each of the displays and the correct driver for that display.

### Adafruit\_CircuitPython\_IL0373

- 1.54” Tri-Color eInk
- 2.13” Tri-Color eInk
- 2.13” Tri-Color eInk FeatherWing
- 2.13” Flexible Monochrome eInk
- 2.9” Flexible Monochrome eInk
- 2.9” Tri-Color eInk

Copy the `adafruit_il0373.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive.

### Adafruit\_CircuitPython\_SSD1608

- 1.54” Monochrome eInk

Copy the `adafruit_ssd1608.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive.

### Adafruit\_CircuitPython\_SSD1675

- 2.13” Monochrome eInk
- 2.13 Monochrome eInk FeatherWing

Copy the `adafruit_ssd1675.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive.

### **Adafruit\_CircuitPython\_IL91874**

- 2.7” Tri-Color eInk

Copy the `adafruit_il91874.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive.

### **Adafruit\_CircuitPython\_IL0398**

- 4.2” Tri-Color eInk

Copy the `adafruit_il0398.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive.

# Usage

To show you how to use the eInk with displayio, we'll show you how to draw a bitmap onto it. First start by downloading **display-ruler.bmp**

[Download display-ruler.bmp](https://github.com/adafruit/Adafruit_CircuitPython_IL0373/raw/main/examples/display-ruler.bmp)
Next copy **display-ruler.bmp** into the root directory of your **CIRCUITPY** drive.

In the examples folder for your displayio driver, there should be a test for your display, which will all be similar, but include specific parameters such as the width and height of the display. In this example, we will examine the 2.9" Tri-color breakout test. Here is the code in its entirety.

Warning: 

```python
import time
import board
import displayio
import fourwire

# Make sure your display driver is uncommented
import adafruit_il0373
#import adafruit_il91874
#import adafruit_ssd1608
#import adafruit_ssd1675
#import adafruit_il0398

# Set based on your display
FLEXIBLE = False
TRICOLOR = True
ROTATION = 90

# Used to ensure the display is free in CircuitPython
displayio.release_displays()

# Define the pins needed for display use
# This pinout is for a Feather M4 and may be different for other boards
# For the Metro/Shield, esc is board.D10 and dc is board.D9
spi = board.SPI()  # Uses SCK and MOSI
ecs = board.D9
dc = board.D10
rst = board.D5    # set to None for FeatherWing/Shield
busy = board.D6   # set to None for FeatherWing/Shield

if TRICOLOR:
    highlight = 0xff0000 #third color is red (0xff0000)
else:
    highlight = 0x000000

# Create the displayio connection to the display pins
display_bus = fourwire.FourWire(spi, command=dc, chip_select=ecs,
                                 reset=rst, baudrate=1000000)

time.sleep(1)  # Wait a bit

# Create the display object
#display = adafruit_ssd1608.SSD1608(display_bus, width=200, height=200,   # 1.54" HD Monochrome
#display = adafruit_ssd1675.SSD1675(display_bus, width=122, height=250,   # 2.13" HD Monochrome
#display = adafruit_il91874.IL91874(display_bus, width=264, height=176,   # 2.7" Tri-color
#display = adafruit_il0398.IL0398(display_bus, width=400, height=300,     # 4.2" Tri-color
#display = adafruit_il0373.IL0373(display_bus, width=152, height=152,     # 1.54" Tri-color
#display = adafruit_il0373.IL0373(display_bus, width=296, height=128, swap_rams=FLEXIBLE, # 2.9" Tri-color OR Flexible Monochrome
display = adafruit_il0373.IL0373(display_bus, width=212, height=104, swap_rams=FLEXIBLE, # 2.13" Tri-color OR Flexible Monochrome
                                 busy_pin=busy, rotation=ROTATION, 
                                 highlight_color=highlight)

# Create a display group for our screen objects
g = displayio.Group()

# Display a ruler graphic from the root directory of the CIRCUITPY drive
f = open("/display-ruler.bmp", "rb")

pic = displayio.OnDiskBitmap(f)
# Create a Tilegrid with the bitmap and put in the displayio group
t = displayio.TileGrid(pic, pixel_shader=displayio.ColorConverter())
g.append(t)

# Place the display group on the screen
display.root_group = g

# Refresh the display to have it actually show the image
# NOTE: Do not refresh eInk displays sooner than 180 seconds
display.refresh()
print("refreshed")

time.sleep(180)
```

We start by importing the libraries that we need. In this case we need `time` for adding delays, board the pin definitions, and of course `displayio`.

```python
import time
import board
import displayio
import fourwire
```

Next you want to uncomment the import statement for the correct driver for your display. This should match the file you copied over earlier. In our case, the 2.9" uses the `adafruit_il0373` driver, so we can leave it as is.

```python
# Make sure your display driver is uncommented
import adafruit_il0373
#import adafruit_il91874
#import adafruit_ssd1608
#import adafruit_ssd1675
#import adafruit_il0398
```

Next we want to set these variables based on your display. If you have a flexible display, you would want to change `FLEXIBLE` to `True`. If you have a monochrome display, you would want to change `TRICOLOR` to `False`. If you would like to change the rotation, you can do that here as well.

```python
# Set based on your display
FLEXIBLE = False
TRICOLOR = True
ROTATION = 90
```

Next we release any previously used displays. This is important because if the Feather is reset, the display pins are not automatically released and this makes them available for use again.

```python
displayio.release_displays()
```

Next we assign the Pins to use. Note that we are not using the SRAM on the eInk display, so we only need to connect the SCK and MOSI SPI pins. We set the SPI object to the board's SPI with the easy shortcut function `board.SPI()`. We also have the ePaper Display **Chip Select** and **Data/Command** pins.

For the breakout boards only, we define the **Reset** and **Busy** pins, otherwise you would change these to None in the case of a shield or FeatherWing.

```python
spi = board.SPI()  # Uses SCK and MOSI
ecs = board.D9
dc = board.D10
rst = board.D5    # can be None to not use this pin
busy = board.D6   # can be None to not use this pin
```

In the next section, we set the highlight color to either red or black based on whether you have a monochrome or tri-color display. You can leave this alone.

```python
if TRICOLOR:
    highlight = 0xff0000 #third color is red (0xff0000)
else:
    highlight = 0x000000
```

In the next line, we set the display bus to FourWire which makes use of the SPI bus. We pass it the `D/C`, and `CS` pins, which are also usually found on TFT displays and if this is a breakout, we also pass in the `reset` pin.

We set the baudrate to 1 MHz instead of the default 24 MHz because the ePaper displays are not about the speed. They are about the patience of waiting many seconds for them to change and the infrequent updates.

After that, we pause for 1 second. Remember, patience.

```python
display_bus = displayio.FourWire(spi, command=epd_dc, chip_select=epd_cs,
                                 reset=epd_reset, baudrate=1000000)
time.sleep(1)
```

Next is the initializer. You will want to uncomment the one appropriate to your display. For the 2.9" display, we would want to comment out the line with **2.13" Tri-color OR Flexible Monochrome** next to it and uncomment the line with **2.9" Tri-color OR Flexible Monochrome** next to it.

```python
# Create the display object
#display = adafruit_ssd1608.SSD1608(display_bus, width=200, height=200,   # 1.54" HD Monochrome
#display = adafruit_ssd1675.SSD1675(display_bus, width=122, height=250,   # 2.13" HD Monochrome
#display = adafruit_il91874.IL91874(display_bus, width=264, height=176,   # 2.7" Tri-color
#display = adafruit_il0398.IL0398(display_bus, width=400, height=300,     # 4.2" Tri-color
#display = adafruit_il0373.IL0373(display_bus, width=152, height=152,     # 1.54" Tri-color
#display = adafruit_il0373.IL0373(display_bus, width=296, height=128, swap_rams=FLEXIBLE, # 2.9" Tri-color OR Flexible Monochrome
display = adafruit_il0373.IL0373(display_bus, width=212, height=104, swap_rams=FLEXIBLE, # 2.13" Tri-color OR Flexible Monochrome
                                 busy_pin=busy, rotation=ROTATION, 
                                 highlight_color=highlight)
```

Next we create a couple of variables including a displayio group and a file handle to the display-ruler.bmp that you placed in your CIRCUITPY root folder. You did do that, right?

```python
# Create a display group for our screen objects
g = displayio.Group()

# Display a ruler graphic from the root directory of the CIRCUITPY drive
f = open("/display-ruler.bmp", "rb")
```

Next we take the file handle and read the bitmap data into a `TileGrid` object. We also specify the pixel\_shader to `displayio.ColorConverter()` because we want `displayio` to convert the image data into something that will look nice on the eInk. We take the TileGrid object and place it into the group.

```python
pic = displayio.OnDiskBitmap(f)
# Create a Tilegrid with the bitmap and put in the displayio group
t = displayio.TileGrid(pic, pixel_shader=displayio.ColorConverter())
g.append(t)
```

In the next line we add the group to the display.

```python
display.root_group = g
```

Finally, we tell the display to refresh so that everything in memory is written out to the display. 

```python
display.refresh()
print("refreshed")
```

Your display will look something like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/490/medium800/adafruit_products_displayio_final.jpg?1571344536)

After that we tell it to pause for 180 seconds or three minutes before continuing where your display would show the REPL.

```python
time.sleep(180)
```

# Adafruit eInk Display Breakouts and FeatherWings

## Python Code

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

# Wiring

It's easy to use eInk breakouts with Python and the [Adafruit CircuitPython EPD](https://github.com/adafruit/Adafruit_CircuitPython_EPD) library.  This library 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 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.

Info: 

Warning: 

- **Raspberry Pi 3.3** to **display VIN**
- **Raspberry Pi GND** to **display GND**
- **Raspberry Pi SCLK** to **display SCK**
- **Raspberry Pi MOSI** to **display MOSI**
- **Raspberry Pi GPIO CE0** to **display ECS**
- **Raspberry Pi GPIO 22** to **display D/C**
- **Raspberry Pi GPIO 27** to **display RST**
- **Raspberry Pi GPIO 17** to **display BUSY**

![adafruit_products_epd_raspberrypi_bb_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/082/560/medium640/adafruit_products_epd_raspberrypi_bb_bb.jpg?1571431977)

# 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 EPD Library

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

- `sudo pip3 install adafruit-circuitpython-epd`

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`

## Download font5x8.bin

**This library also requires a font file to run!** You can download it below. Before continuing, make sure the folder you are running scripts from contains the **font5x8.bin** file.

[Download font5x8.bin](https://github.com/adafruit/Adafruit_CircuitPython_framebuf/raw/master/examples/font5x8.bin)
## 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

Some of the examples also use PIL, the Python Imaging Library, to allow graphics and 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.

# Usage

To demonstrate the usage of the display we'll initialize it and draw some lines from the Python REPL.

Run the following code to import the necessary modules and set up the pin assignments:

```python
import digitalio
import busio
import board
from adafruit_epd.epd import Adafruit_EPD

spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
ecs = digitalio.DigitalInOut(board.CE0)
dc = digitalio.DigitalInOut(board.D22)
rst = digitalio.DigitalInOut(board.D27)
busy = digitalio.DigitalInOut(board.D17)
srcs = None
```

If you're using the 1.54" Tri-Color display, run the following code to initialize the display:

```python
from adafruit_epd.il0373 import Adafruit_IL0373
display = Adafruit_IL0373(152, 152, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

If you're using the 2.13" Tri-Color display, run the following code to initialize the display:

```python
from adafruit_epd.il0373 import Adafruit_IL0373
display = Adafruit_IL0373(104, 212, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

If you're using the 2.9" Tri-Color display, run the following code to initialize the display:

```python
from adafruit_epd.il0373 import Adafruit_IL0373
display = Adafruit_IL0373(128, 296, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

If you're using the 2.7" Tri-Color display, run the following code to initialize the display:

```python
from adafruit_epd.il91874 import Adafruit_IL91874
display = Adafruit_IL91874(176, 264, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

If you're using the 4.2" Tri-Color display, run the following code to initialize the display:

```python
from adafruit_epd.il0398 import Adafruit_IL0398
display = Adafruit_IL0398(400, 300, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

If you're using the 1.54" HD Monochrome display, run the following code to initialize the display:

```python
from adafruit_epd.ssd1608 import Adafruit_SSD1608
display = Adafruit_SSD1608(200, 200, spi, cs_pin=ecs, dc_pin=dc, sramcs_pin=srcs,
                          rst_pin=rst, busy_pin=busy)
```

## Tri-Color Example

Now we can clear the screens buffer and draw some shapes. Once we're done drawing, we need to tell the screen to update using the `display()` method.

```python
display.fill(Adafruit_EPD.WHITE)

display.fill_rect(20, 20, 50, 60, Adafruit_EPD.RED)
display.hline(80, 30, 60, Adafruit_EPD.BLACK)
display.vline(80, 30, 60, Adafruit_EPD.BLACK)

display.display()
```

Your display will look something like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/671/medium800/adafruit_products_tri-color_example.jpeg?1571693621)

## Monochrome Example

Now we can clear the screens buffer and draw some shapes. Once we're done drawing, we need to tell the screen to update using the `display()` method.

```python
display.fill(Adafruit_EPD.WHITE)

display.fill_rect(0, 0, 50, 60, Adafruit_EPD.BLACK)
display.hline(80, 30, 60, Adafruit_EPD.BLACK)
display.vline(80, 30, 60, Adafruit_EPD.BLACK)

display.display()
```

Your eInk display should look similar to the image above, with a black rectangle instead of a red one.

![](https://cdn-learn.adafruit.com/assets/assets/000/082/673/medium800/adafruit_products_monochrome_example.jpeg?1571694080)

That's all there is to drawing simple shapes with eInk displays and CircuitPython!

# Tri-Color Bitmap Example

Here's a complete example of how to display a bitmap image on your display. **Note that any .bmp image you want to display must be exactly the size of your display.** We will be using the image below on the 1.54" display. Click the button below to download the image and save it as  **blinka.bmp** on your **Raspberry Pi**.

![](https://cdn-learn.adafruit.com/assets/assets/000/082/626/medium800/adafruit_products_blinka.bmp?1571676087)

[Click here to download blinka for the 1.54" display](https://cdn-learn.adafruit.com/assets/assets/000/057/705/original/adafruit_products_blinka.bmp)
Save the following code to your Raspberry Pi as **epd\_bitmap.py**.

https://github.com/adafruit/Adafruit_CircuitPython_EPD/blob/main/examples/epd_bitmap.py

Before running it, we need to change a few pin definitions though. Find the section of code that looks like this:

```python
ecs = digitalio.DigitalInOut(board.D10)
dc = digitalio.DigitalInOut(board.D9)
srcs = digitalio.DigitalInOut(board.D7)    # can be None to use internal memory
rst = digitalio.DigitalInOut(board.D11)    # can be None to not use this pin
busy = digitalio.DigitalInOut(board.D12)   # can be None to not use this pin
```

Change the pins to the following to match the wiring on the Raspberry Pi:

```python
ecs = digitalio.DigitalInOut(board.CE0)
dc = digitalio.DigitalInOut(board.D22)
srcs = None
rst = digitalio.DigitalInOut(board.D27)
busy = digitalio.DigitalInOut(board.D17)
```

Now go to the command prompt on your Raspberry Pi and run the script with the following command:

`python3 epd_bitmap.py`

After a few seconds, your display should show this image:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/627/medium800/adafruit_products_3625_kit_ORIG_2018_07.jpg?1571678170)

# Full Example Code

Here is the full example code.

Info: 

https://github.com/adafruit/Adafruit_CircuitPython_EPD/blob/main/examples/epd_simpletest.py

# Image Drawing with Pillow

In this image, we will use Pillow to resize and crop the image automatically and draw it the the ePaper Display. Pillow is really powerful and with it you can open and render additional file formats such as PNG or JPG. Let's start with downloading a PNG of blinka that has been adjusted down to 3 colors so it prints nicely on an ePaper Display. We are using PNG for this because it is a lossless format and won't introduce unexpected colors in.

![](https://cdn-learn.adafruit.com/assets/assets/000/082/717/medium800/adafruit_products_blinka.png?1571699449)

Make sure you save it as  **blinka.png** and place it in the same folder as your script. Here's the code we'll be loading onto the Raspberry Pi. Go ahead and copy it onto your Raspberry Pi and save it as **epd\_pillow\_image.py**. We'll go over the interesting parts.

https://github.com/adafruit/Adafruit_CircuitPython_EPD/blob/main/examples/epd_pillow_image.py

So we start with our usual imports including a couple of Pillow modules and the ePaper display drivers.

```python
import digitalio
import busio
import board
from PIL import Image, ImageDraw
from adafruit_epd.il0373 import Adafruit_IL0373
from adafruit_epd.il91874 import Adafruit_IL91874
from adafruit_epd.il0398 import Adafruit_IL0398
from adafruit_epd.ssd1608 import Adafruit_SSD1608
from adafruit_epd.ssd1675 import Adafruit_SSD1675
```

That is followed by initializing the SPI bus and defining a few pins here. The reason we chose these is because they allow you to use the same code with the EPD bonnets if you chose to do so.

```python
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
ecs = digitalio.DigitalInOut(board.CE0)
dc = digitalio.DigitalInOut(board.D22)
srcs = None
rst = digitalio.DigitalInOut(board.D27)
busy = digitalio.DigitalInOut(board.D17)
```

We wanted to make these examples work on as many displays as possible with very few changes. The 2.13" Tri-color display is selected by default. For other displays, go ahead and comment out the following lines:

`display = Adafruit_IL0373(    104,    212,  # 2.13" Tri-color display`

and uncomment the line appropriate for your display. 

```python
#display = Adafruit_SSD1608(200, 200,        # 1.54" HD mono display
#display = Adafruit_SSD1675(122, 250,        # 2.13" HD mono display
#display = Adafruit_IL91874(176, 264,        # 2.7" Tri-color display
#display = Adafruit_IL0373(152, 152,         # 1.54" Tri-color display
#display = Adafruit_IL0373(128, 296,         # 2.9" Tri-color display
#display = Adafruit_IL0398(400, 300,         # 4.2" Tri-color display
display = Adafruit_IL0373(
    104,
    212,  # 2.13" Tri-color display
    spi,
    cs_pin=ecs,
    dc_pin=dc,
    sramcs_pin=srcs,
    rst_pin=rst,
    busy_pin=busy
)
```

Uncomment the next two lines if you have a flexible display. This tells the library to change a couple of settings so that it is writing the correct colors to the correct places.

```python
# IF YOU HAVE A FLEXIBLE DISPLAY (2.13" or 2.9") uncomment these lines!
#display.set_black_buffer(1, False)
#display.set_color_buffer(1, False)
```

Next we tall the display the rotation setting we want to use. This can be a value between `0-3`.

```python
display.rotation = 1
```

Next we open the Blinka image, which we've named  **blinka.png** , which assumes it is in the same directory that you are running the script from. Feel free to change it if it doesn't match your configuration.

```python
image = Image.open("blinka.png")
```

Here's where it starts to get interesting. We want to scale the image so that it matches either the width or height of the display, depending on which is smaller, so that we have some of the image to chop off when we crop it. So we start by calculating the width to height ration of both the display and the image. If the height is the closer of the dimensions, we want to match the image height to the display height and let it be a bit wider than the display. Otherwise, we want to do the opposite.

Once we've figured out how we're going to scale it, we pass in the new dimensions and using a  **Bicubic**  rescaling method, we reassign the newly rescaled image back to `image`. Pillow has quite a few different methods to choose from, but Bicubic does a great job and is reasonably fast.

**Nearest** actually gives a little better result with the Tri-color eInks, but loses detail with displaying a color image on the monochrome display, so we decided to go with the best balance.

```python
image_ratio = image.width / image.height
screen_ratio = display.width / display.height
if screen_ratio < image_ratio:
    scaled_width = image.width * display.height // image.height
    scaled_height = display.height
else:
    scaled_width = display.width
    scaled_height = image.height * display.width // image.width
image = image.resize((scaled_width, scaled_height), Image.BICUBIC)
```

Next we want to figure the starting x and y points of the image where we want to begin cropping it so that it ends up centered. We do that by using a standard centering function, which is basically requesting the difference of the center of the display and the center of the image. Just like with scaling, we replace the `image` variable with the newly cropped image.

```python
x = scaled_width // 2 - display.width // 2
y = scaled_height // 2 - display.height // 2
image = image.crop((x, y, x + display.width, y + display.height))
```

Finally, we take our `image`, draw it to the frame buffer and `display` it. At this point, the image should have the exact same dimensions at the display and fill it completely.

```python
display.image(image)
display.display()
```

Now go to the command prompt on your Raspberry Pi and run the script with the following command:

`python3 epd_pillow_image.py`

After a few seconds, your display should show this image:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/723/medium800/adafruit_products_pillow-image-color.jpeg?1571702512)

Here's what it looks like on a monochrome display:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/725/medium800/adafruit_products_pillow-image-monochrome.jpeg?1571704033)

# Drawing Shapes and Text with Pillow

In the next example, we'll take a look at drawing shapes and text. This is very similar to the displayio example, but it uses Pillow instead. Go ahead and copy it onto your Raspberry Pi and save it as **epd\_pillow\_demo.py**. Here's the code for that.

https://github.com/adafruit/Adafruit_CircuitPython_EPD/blob/main/examples/epd_pillow_demo.py

Just like in the last example, we'll do our imports, but this time we're including the `ImageDraw` and `ImageFont` Pillow modules because we'll be drawing some text this time.

```python
import digitalio
import busio
import board
from PIL import Image, ImageDraw, ImageFont
from adafruit_epd.il0373 import Adafruit_IL0373
from adafruit_epd.il91874 import Adafruit_IL91874
from adafruit_epd.il0398 import Adafruit_IL0398
from adafruit_epd.ssd1608 import Adafruit_SSD1608
from adafruit_epd.ssd1675 import Adafruit_SSD1675
```

Next we define some colors that can be used with Pillow.

```python
WHITE = (0xFF, 0xFF, 0xFF)
BLACK = (0x00, 0x00, 0x00)
RED = (0xFF, 0x00, 0x00)
```

After that, we create some parameters that are easy to change. If you had a smaller display for instance, you could reduce the `FONTSIZE` and `BORDER` parameters. The `BORDER` will be the size in pixels of the green border between the edge of the display and the inner purple rectangle. The `FONTSIZE` will be the size of the font in points so that we can adjust it easily for different displays. You could play around with the colors as well. One thing to note is that on monochrome displays, the `RED` will show up as `BLACK`.

```python
BORDER = 20
FONTSIZE = 24
BACKGROUND_COLOR = BLACK
FOREGROUND_COLOR = WHITE
TEXT_COLOR = RED
```

After that, the initializer and rotation sections are exactly the same as in the previous example. **If you have are using a different display than the 2.13" Tri-color, go ahead and adjust your initializer as explained in the previous example.** After that, we will create an `image` with our dimensions and use that to create a `draw` object.  The `draw` object will have all of our drawing functions.

```python
image = Image.new('RGB', (display.width, display.height))

draw = ImageDraw.Draw(image)
```

Next we clear whatever is on the screen by drawing a rectangle using the `BACKGROUND_COLOR` that takes up the full screen.

```python
draw.rectangle((0, 0, display.width, display.height), fill=BACKGROUND_COLOR)
```

Next we will draw an inner rectangle using the `FOREGROUND_COLOR`. We use the `BORDER` parameter to calculate the size and position that we want to draw the rectangle.

```python
draw.rectangle((BORDER, BORDER, display.width - BORDER - 1, display.height - BORDER - 1),
               fill=FOREGROUND_COLOR)
```

Next we'll load a TTF font. The `DejaVuSans.ttf` font should come preloaded on your Pi in the location in the code. We also make use of the `FONTSIZE` parameter that we discussed earlier.

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

Now we draw the text Hello World onto the center of the display. You may recognize the centering calculation was the same one we used to center crop the image in the previous example. In this example though, we get the font size values using the `getsize()` function of the font object.

```python
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=TEXT_COLOR)
```

Finally, just like before, we display the image.

```python
display.image(image)
display.display()
```

Now go to the command prompt on your Raspberry Pi and run the script with the following command:

`python3 epd_pillow_demo.py`

After a few seconds, your display should show this image:

![](https://cdn-learn.adafruit.com/assets/assets/000/082/762/medium800/adafruit_products_pillow-demo-color.jpeg?1571767349)

# Adafruit eInk Display Breakouts and FeatherWings

## Python Docs

# Adafruit eInk Display Breakouts and FeatherWings

## 2.9" Grayscale eInk FeatherWing

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/096/231/medium800thumb/adafruit_products_2.9%22_Grayscale_eInk__FeatherWing.jpg?1603380133)

Easy e-paper comes to your Feather with this breakout that's designed to make it a breeze to add a monochrome eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static' displays - that means the image stays on the display even when power is completely disconnected. The image is also high contrast and very daylight readable. It really does look just like printed paper!

We've liked these displays for a long time, so wouldn't a custom e-paper FeatherWing with buttons make a ton of sense? ** This 'Wing is tested to work with _all_ of our Feathers** , from the ESP8266 to the M0. It has built in memory buffering so it can work with chips as small as the '32u4 and '328. It _does_ use a lot of pins: the 3 SPI pins, and up to 4 control pins to manage the SD card slot and SRAM. Plus 3 optional buttons are available for Feathers with available pins.

The FeatherWing sports a  **2.9" grayscale display****  with 296x128 pixels**. Each pixel can be white, light gray, dark gray or black. Compared to 'tri-color' displays with a red pigment, this display takes a lot less time to update, only about a second instead of 15 seconds!

Using our CircuitPython or Arduino libraries, you can create a 'frame buffer' with what pixels you want to have activated and then write that out to the display. Most simple breakouts leave it at that. But if you do the math, 296 x 128 pixels x 2-bits-per-pixel = 9.5 KBytes. Which won't fit into many microcontroller memories. Heck, even if you do have 32KB of RAM, why waste 9KB?

**So we did you a favor and tossed a small SRAM chip on the back.**  This chip shares the SPI port the eInk display uses, so you only need one extra pin. And, no more frame-buffering! **You can use the SRAM to set up whatever you want to display, then shuffle data from SRAM to eInk when you're ready. [The library we wrote does all the work for you](https://github.com/adafruit/Adafruit_EPD)**[, you can just interface with it as if it were an Adafruit\_GFX compatible display](https://github.com/adafruit/Adafruit_EPD).

We even tossed on a MicroSD socket so you can store images, text files, whatever you like to display. Comes assembled and tested with socket headers that you can plug your Feather right into, no soldering required!

# Adafruit eInk Display Breakouts and FeatherWings

## Pinouts

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/096/573/medium800/adafruit_products_Pinouts.jpg?1604003342)

This e-Paper display uses SPI to receive image data. Since the display is SPI, it was easy to add two more SPI devices to share the bus - an SPI SRAM chip and SPI-driven SD card holder. There's quite a few pins and a variety of possible combinations for control depending on your needs.

## Power Pins
- **3V**  - this is the power pin, and connects to the Feather 3V power supply output
- **GND ** - this is the power and signal ground pin

![adafruit_products_Power.jpg](https://cdn-learn.adafruit.com/assets/assets/000/096/574/medium640/adafruit_products_Power.jpg?1604003410)

## Buttons
The buttons are connected to Digital Input pins. Pressing the button brings the pin low. There are no pull-up resistors connected, so you will need to enable those in software.

![adafruit_products_Buttons.jpg](https://cdn-learn.adafruit.com/assets/assets/000/096/576/medium640/adafruit_products_Buttons.jpg?1604003646)

The numbers of the pins these correspond to will differ from board to board. However, on 32u4/328p/M0/M4/nRF52840 and many other boards you will see the following connections:

- **A Button**  - this is connected to D11 of the feather
- **B Button**  - this is connected to D12 of the feather
- **C Button**  - this is connected to D13 of the feather

## Data Control Pins
The FeatherWing uses SPI and some control pins for reading/writing data from the SD and then sending data to the E-Ink display

![adafruit_products_Data.jpg](https://cdn-learn.adafruit.com/assets/assets/000/096/575/medium640/adafruit_products_Data.jpg?1604003493)

SPI data pins

- **SCK**  - this is the SPI clock input pin, required for e-Ink, SRAM and SD card
- **MISO ** - this is the SPI Microcontroller In Serial Out pin, its used for the SD card and SRAM. It isn't used for the e-Ink display which is write-only, however you'll likely be using the SRAM to buffer the display.
- **MOSI ** - this is the SPI Microcontroller Out Serial In pin, it is used to send data from the microcontroller to the SD card, SRAM and e-Ink display

SPI control pins

- **ECS**  - this is the  **E** -Ink  **C** hip  **S** elect, required for controlling the display
- **SRCS**  - this is the  **S**** R **AM ** C **hip ** S**elect, required for communicating with the onboard RAM chip.
- **SDCS**  - this is the  **SD**  card  **C** hip  **S** elect, required for communicating with the onboard SD card holder. You can leave this disconnected if you aren't going to access SD cards

Other control pins

- **D/C**  - this is the e-Ink  **D** ata/ **C** ommand pin, required for controlling the display
- **RST**  - this is connected to the microcontroller reset circuitry, so you don't need to worry about it in software.

Optional control pads:

- **BUSY**  - this is the e-Ink busy detect pad and is optional if you don't want to connect the pin (in which case the code will just wait an approximate number of seconds). To use it, you will need to run a wire over to it.

SD CS, SRAM CS, EINK CS and DC are in order after the two I2C pins. The numbers of the pins these correspond to will differ from board to board. However, on 32u4/328p/M0/M4/nRF52840 and many other boards you will see the following connections

- **SD CS**  to Pin  **D5**
- **SRAM CS**  to Pin  **D6**
- **EINK CS**  to Pin ** D9**
- **EINK DC**  to Pin ** D10**

If you do not plan to use the SD card, you can cut the trace to SD CS.   
Likewise if you do not plan to use the built in SRAM, say because you're in CircuitPython or if you are using Arduino and have a lot of RAM in your controller, you can cut the trace for SRAM CS.

# Adafruit eInk Display Breakouts and FeatherWings

## Wiring

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

## FeatherWing Connection

FeatherWing usage is easy, simply plug your Feather into the Wing

![](https://cdn-learn.adafruit.com/assets/assets/000/096/234/medium800/adafruit_products_FeatherWing_bb.jpg?1603386177)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/096/235/original/FeatherWing.fzz?1603386200)
# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Usage

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

For this display we will run a 4-level grayscale demo

Open up **File→Examples→Adafruit\_EPD→**** ThinkInk\_gray4**

![](https://cdn-learn.adafruit.com/assets/assets/000/096/251/medium800/adafruit_products_Open_Demo_Gray4.png?1603397338)

# Configure Pins

At the top of the sketch find the lines that look like:

```cpp
#define EPD_DC      10
#define EPD_CS      9
#define SRAM_CS     6
#define EPD_RESET   8 // can set to -1 and share with microcontroller Reset!
#define EPD_BUSY    7 // can set to -1 to not use a pin (will wait a fixed delay)
```

Change both `EPD_RESET` and `EPD_BUSY` to **-1** since neither of these lines are connected on the FeatherWing.

You'll also need to update the CS and DC pins if you're not using a Feather M0 or M4. For example, on an ESP8266

`#define SRAM_CS 16`  
`#define EPD_CS 0`  
`#define EPD_DC 15`

# Configure Display Size

Find the part of the script where you can pick which display is going to be used.

For the 2.9" Grayscale Featherwing, you will need to have `ThinkInk_290_Grayscale4_T5` uncommented, and any other type commented.

Fine this line and make sure it is not commented out:

```python
// 2.9" Grayscale Featherwing or Breakout:
ThinkInk_290_Grayscale4_T5 display(EPD_DC, EPD_RESET, EPD_CS, SRAM_CS, EPD_BUSY);
```

# Upload Sketch

Go ahead and upload the sketch to your board. Once it is done uploading, open the **Serial Monitor**.

![](https://cdn-learn.adafruit.com/assets/assets/000/096/259/medium800/adafruit_products_Serial_Monitor.png?1603405703)

The display should start running a series of monochrome and grayscale tests.

![](https://cdn-learn.adafruit.com/assets/assets/000/096/265/medium800thumb/adafruit_products_2.9_Grayscale_Running_Demo.jpg?1603465950)

# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Bitmaps

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/096/271/medium800/adafruit_products_4777-07.jpg?1603484562)

Not only can you draw shapes but you can also load images from the SD card, perfect for static images!

The 2.9" Grayscale display can show a max of 296x128 pixels. Lets use these three bitmaps for our demo:

![](https://cdn-learn.adafruit.com/assets/assets/000/096/272/medium800/adafruit_products_panda_head.bmp?1603484642)

[Download panda_head.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/272/original/adafruit_products_panda_head.bmp?1603484642)
![](https://cdn-learn.adafruit.com/assets/assets/000/096/273/medium800/adafruit_products_adabot_head.bmp?1603484658)

[Download adabot_head.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/273/original/adafruit_products_adabot_head.bmp?1603484658)
![](https://cdn-learn.adafruit.com/assets/assets/000/096/274/medium800/adafruit_products_29gray4.bmp?1603484677)

[Download 29gray4.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/274/original/adafruit_products_29gray4.bmp?1603484677)
Rename the files to **panda\_head.bmp** , **adabot\_head.bmp** , and **29gray4.bmp** and place them into the base directory of a microSD card and insert it into the microSD socket in the breakout.

Plug the MicroSD card into the display. You may want to try the **SD library** examples before continuing, especially one that lists all the files on the SD card

Open the **file-\>examples-\>Adafruit\_ImageReader-\>EInkGray29BmpButtonDemo**  example

![](https://cdn-learn.adafruit.com/assets/assets/000/096/393/medium800/adafruit_products_ImageReader_Button_Demo.png?1603727410)

Upload to your board and press the buttons on top. You should see a different image appear for each button.

![](https://cdn-learn.adafruit.com/assets/assets/000/096/275/medium800thumb/adafruit_products_Bitmap_Demo.jpg?1603490204)

# Adafruit eInk Display Breakouts and FeatherWings

## CircuitPython Code

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

## CircuitPython eInk displayio Library Installation

To use displayio, you will need to install the appropriate library for your display. 

First make sure you are running the [latest version of Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython) for your board. You will need the latest version of CircuitPython.

Warning: 

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).  Our introduction guide has [a great page on how to install the library bundle](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries) for both express and non-express boards.

You will need to copy the appropriate displayio driver from the bundle **lib** folder to a **lib** folder on your **CIRCUITPY** drive. The displayio driver contains the initialization codes specific to your display that are needed to for it to work. Since there is more than one driver, you will need to copy the correct file over. Here is a list of each of the displays and the correct driver for that display.

Info: 

### Adafruit\_CircuitPython\_IL0373

This display uses the Adafruit\_CircuitPython\_ILI0373 library. Copy the `adafruit_il0373.mpy` file from the bundle to the **lib** folder on your **CIRCUITPY** drive. You will want a recent version grayscale support was first added in version 1.3.1.

## Usage

To show you how to use the eInk with displayio, we'll show you how to draw a bitmap onto it. First start by downloading **display-ruler.bmp**

[Download display-ruler.bmp](https://github.com/adafruit/Adafruit_CircuitPython_IL0373/raw/main/examples/display-ruler.bmp)
Next copy **display-ruler.bmp** into the root directory of your **CIRCUITPY** drive.

In the examples folder for your displayio driver, there should be a test for your display which we have listed here:

https://github.com/adafruit/Adafruit_CircuitPython_IL0373/blob/main/examples/il0373_2.9_grayscale.py

Save it to your **CIRCUITPY** drive as **code.py** and it should automatically run. Your display will look something like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/096/579/medium800/adafruit_products_CircuitPython_Demo.jpeg?1604010915)

# Adafruit eInk Display Breakouts and FeatherWings

## Downloads

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

## Files

- [Fritzing object in Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library/blob/master/parts/Adafruit%202.9in%20eInk%20Under%20FeatherWing.fzpz)
- [IL0376F E-Ink interface chip datasheet](https://cdn-learn.adafruit.com/assets/assets/000/057/648/original/IL0376F.pdf)
- [PCB Files on GitHub](https://github.com/adafruit/Adafruit-E-Paper-Display-Breakout-PCBs)

## Schematic
![](https://cdn-learn.adafruit.com/assets/assets/000/096/577/medium800/adafruit_products_Schematic.png?1604005386)

## Fab Print
![](https://cdn-learn.adafruit.com/assets/assets/000/096/578/medium800/adafruit_products_Fab_Print.png?1604005419)

# Adafruit eInk Display Breakouts and FeatherWings

## 2.9" Tri-Color eInk

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

![](https://cdn-learn.adafruit.com/assets/assets/000/096/276/medium800/adafruit_products_4778_top_ORIG_2020_10.jpg?1603493934)

This breakout has a **2.9" tri-color (red, black, and white) display**. It has 296x128 black and red ink pixels and a white-ish background. Using our CircuitPython or Arduino libraries, you can create a 'frame buffer' with what pixels you want to have activated and then write that out to the display. Most simple breakouts leave it at that. But if you do the math, 296 x 128 pixels x 2 colors = 9.5 KBytes. Which won't fit into many microcontroller memories. Heck, even if you do have 32KB of RAM, why waste 10KB?

**So we did you a favor and tossed a small SRAM chip on the back.**  This chip shares the SPI port the eInk display uses, so you only need one extra pin. And, no more frame-buffering! **You can use the SRAM to set up whatever you want to display, then shuffle data from SRAM to eInk when you're ready. [The library we wrote does all the work for you](https://github.com/adafruit/Adafruit_EPD)**[, you can just interface with it as if it were an Adafruit\_GFX compatible display](https://github.com/adafruit/Adafruit_EPD).

For ultra-low power usages, the onboard 3.3V regulator has the Enable pin brought out so you can shut down the power to the SRAM, MicroSD and display.

We even tossed on a MicroSD socket so you can store images, text files, whatever you like to display. Everything is 3 or 5V logic safe so you can use it with any and all microcontrollers.

# Adafruit eInk Display Breakouts and FeatherWings

## Wiring

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

## Breakout Wiring

Wiring up the display in SPI mode is pretty easy as there's not that many pins! We'll be using hardware SPI, but you can also use software SPI (any pins) later.

- **Vin** connects to the microcontroller board's **5V** or **3.3V** power supply pin
- **GND** connects to ground
- **CLK** connects to SPI clock. It's easiest to connect it to **pin 3 of the ICSP header**.
- **MOSI** connects to SPI MOSI. It's easiest to connect it to **pin 4 of the ICSP header**.
- **MISO** connects to SPI MISO. It's easiest to connect it to **pin 1 of the ICSP header**.
- **ECS** connects to our e-Ink Chip Select pin. We'll be using **Digital 9**
- **D/C** connects to our e-Ink data/command select pin. We'll be using **Digital 10**.
- **SRCS** connects to our SRAM Chip Select pin. We'll be using **Digital 6**
- **RST** connects to our e-Ink reset pin. We'll be using **Digital 8**.
- **BUSY** connects to our e-Ink busy pin. We'll be using **Digital 7**.
- **SDCS** connects to our SD Card Chip Select pin. We'll be using **Digital 5**

![adafruit_products_one_one_one.png](https://cdn-learn.adafruit.com/assets/assets/000/125/977/medium640/adafruit_products_one_one_one.png?1699565582)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/096/442/original/Breakout.fzz?1603776521)
## FeatherWing Connection

FeatherWing usage is easy, simply plug your Feather into the Wing

![](https://cdn-learn.adafruit.com/assets/assets/000/096/234/medium800/adafruit_products_FeatherWing_bb.jpg?1603386177)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/096/235/original/FeatherWing.fzz?1603386200)
## Python Wiring
- **Raspberry Pi 3.3** to **display VIN**
- **Raspberry Pi GND** to **display GND**
- **Raspberry Pi SCLK** to **display SCK**
- **Raspberry Pi MOSI** to **display MOSI**
- **Raspberry Pi GPIO CE0** to **display ECS**
- **Raspberry Pi GPIO 22** to **display D/C**
- **Raspberry Pi GPIO 27** to **display RST**
- **Raspberry Pi GPIO 17** to **display BUSY**

![adafruit_products_Python_bb.png](https://cdn-learn.adafruit.com/assets/assets/000/125/978/medium640/adafruit_products_Python_bb.png?1699565698)

[Download Fritzing Diagram](https://cdn-learn.adafruit.com/assets/assets/000/096/454/original/Python.fzz?1603815992)
# Adafruit eInk Display Breakouts and FeatherWings

## Arduino Usage

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

Open up **File→Examples→Adafruit\_EPD→**** ThinkInk\_tricolor**

![](https://cdn-learn.adafruit.com/assets/assets/000/096/280/medium800/adafruit_products_Open_Demo_Tricolor.png?1603496295)

At the top of the sketch find the lines that look like:

```cpp
#define EPD_CS      9
#define EPD_DC      10
#define SRAM_CS     6
#define EPD_RESET   8 // can set to -1 and share with microcontroller Reset!
#define EPD_BUSY    7 // can set to -1 to not use a pin (will wait a fixed delay)
```

## FeatherWing Wiring

If you are using the FeatherWing, change both `EPD_RESET` and `EPD_BUSY` to **-1** since neither of these lines are connected.

You'll also need to update the EPD\_DC, EPD\_CS and SRAM\_CS pins if you're not using a Feather M0 or M4. For example, on an ESP8266

`#define SRAM_CS 16`  
`#define EPD_CS 0`  
`#define EPD_DC 15`

## Breakout Wiring

If you are using the Breakout, just upload the sketch as it is.

Once it is done uploading, open the **Serial Monitor**.

![](https://cdn-learn.adafruit.com/assets/assets/000/096/259/medium800/adafruit_products_Serial_Monitor.png?1603405703)

The display should start running a series of monochrome and grayscale tests.

![](https://cdn-learn.adafruit.com/assets/assets/000/096/435/medium800thumb/adafruit_products_Tricolor_Demo.jpg?1603748073)

# Adafruit eInk Display Breakouts and FeatherWings

## Downloads

Updated guides have been published for the different sizes of eInk Breakouts, Shields, and FeatherWings:

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields)
- [Adafruit 2.9" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-9-eink-display-breakouts-and-featherwings)

# Files

- [Fritzing object in Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library)
- [IL0376F E-Ink interface chip datasheet](https://cdn-learn.adafruit.com/assets/assets/000/057/648/original/IL0376F.pdf)
- [PCB Files on GitHub](https://github.com/adafruit/Adafruit-E-Paper-Display-Breakout-PCBs)

[SSD1675 driver datasheet](https://cdn-learn.adafruit.com/assets/assets/000/092/748/original/SSD1675_0.pdf?1593792604)
Display shape/outline:

![](https://cdn-learn.adafruit.com/assets/assets/000/057/649/medium800/adafruit_products_GDEW0154Z04.jpg?1531712867)

# Schematic & Fabrication Prints
## Shared schematic for 1.54" 2.13" and 2.7" Breakouts
![](https://cdn-learn.adafruit.com/assets/assets/000/057/645/medium800/adafruit_products_schem.png?1531712746)

![](https://cdn-learn.adafruit.com/assets/assets/000/057/646/medium800/adafruit_products_fabprint.png?1531712755)

![](https://cdn-learn.adafruit.com/assets/assets/000/071/121/medium800/adafruit_products_Adafruit_2.13in_eInk_Fab_Print.png?1550094800)

![](https://cdn-learn.adafruit.com/assets/assets/000/071/122/medium800/adafruit_products_Adafruit_2.7in_eInk_Fab_Print.png?1550094819)

## 2.9 Inch Display
![](https://cdn-learn.adafruit.com/assets/assets/000/080/858/medium800/adafruit_products_2_9_schematic.png?1568397083)

![](https://cdn-learn.adafruit.com/assets/assets/000/082/069/medium800/adafruit_products_2_9inch_eInk_Fab_Print.png?1570215841)

# eInk Friends
![](https://cdn-learn.adafruit.com/assets/assets/000/086/035/medium800/adafruit_products_Feather_eInk_Friend_sch.png?1576774972)

![](https://cdn-learn.adafruit.com/assets/assets/000/086/036/medium800/adafruit_products_Feather_eInk_Friend_fab_print.png?1576774985)

![](https://cdn-learn.adafruit.com/assets/assets/000/086/038/medium800/adafruit_products_Breakout_eInk_Friend_sch.png?1576775087)

![](https://cdn-learn.adafruit.com/assets/assets/000/086/039/medium800/adafruit_products_Breakout_eInk_Friend_fab_print.png?1576775105)

# 2.7" Shield
![](https://cdn-learn.adafruit.com/assets/assets/000/091/737/medium800/adafruit_products_2-7-in-eink-shield-sch.png?1591212452)

![](https://cdn-learn.adafruit.com/assets/assets/000/091/738/medium800/adafruit_products_2-7-in-eink-shield-fab-print.png?1591212460)


## Featured Products

### Adafruit 1.54" 152x152 Tri-Color eInk / ePaper Display with SRAM

[Adafruit 1.54" 152x152 Tri-Color eInk / ePaper Display with SRAM](https://www.adafruit.com/product/3625)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a tri-color eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

No Longer Stocked
[Buy Now](https://www.adafruit.com/product/3625)
[Related Guides to the Product](https://learn.adafruit.com/products/3625/guides)
### Adafruit 1.54" Monochrome eInk / ePaper Display with SRAM

[Adafruit 1.54" Monochrome eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4196)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add an eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static' displays -...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4196)
[Related Guides to the Product](https://learn.adafruit.com/products/4196/guides)
### Adafruit 2.13" Tri-Color eInk / ePaper Display with SRAM

[Adafruit 2.13" Tri-Color eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4086)
Discontinued - [**you can grab** Adafruit 2.13" 250x122 Tri-Color eInk / ePaper Display with SRAM - SSD1680 Driver  **instead! **](https://www.adafruit.com/product/4947)

Easy e-paper finally comes to microcontrollers, with this breakout that's designed...

No Longer Stocked
[Buy Now](https://www.adafruit.com/product/4086)
[Related Guides to the Product](https://learn.adafruit.com/products/4086/guides)
### Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM

[Adafruit 2.13" Monochrome eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4197)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a monochromatic eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

In Stock
[Buy Now](https://www.adafruit.com/product/4197)
[Related Guides to the Product](https://learn.adafruit.com/products/4197/guides)
### Adafruit 2.13" Tri-Color eInk / ePaper Display FeatherWing

[Adafruit 2.13" Tri-Color eInk / ePaper Display FeatherWing](https://www.adafruit.com/product/4128)
Easy e-paper finally comes to your Feather, with this breakout that's designed to make it a breeze to add a tri-color eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

No Longer Stocked
[Buy Now](https://www.adafruit.com/product/4128)
[Related Guides to the Product](https://learn.adafruit.com/products/4128/guides)
### Adafruit 2.13" Monochrome eInk / ePaper Display FeatherWing

[Adafruit 2.13" Monochrome eInk / ePaper Display FeatherWing](https://www.adafruit.com/product/4195)
Easy e-paper finally comes to your Feather, with this breakout that's designed to make it a breeze to add a monochrome eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4195)
[Related Guides to the Product](https://learn.adafruit.com/products/4195/guides)
### Adafruit 2.7" Tri-Color eInk / ePaper Display with SRAM

[Adafruit 2.7" Tri-Color eInk / ePaper Display with SRAM](https://www.adafruit.com/product/4098)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a tri-color eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4098)
[Related Guides to the Product](https://learn.adafruit.com/products/4098/guides)
### Adafruit 2.7" Tri-Color eInk / ePaper Shield with SRAM

[Adafruit 2.7" Tri-Color eInk / ePaper Shield with SRAM](https://www.adafruit.com/product/4229)
Easy e-paper finally comes to microcontrollers, with this breakout that's designed to make it a breeze to add a tri-color eInk display. Chances are you've seen one of those new-fangled 'e-readers' like the Kindle or Nook. They have gigantic electronic paper 'static'...

Out of Stock
[Buy Now](https://www.adafruit.com/product/4229)
[Related Guides to the Product](https://learn.adafruit.com/products/4229/guides)

## Related Guides

- [Adafruit 1.54" eInk Display Breakouts](https://learn.adafruit.com/adafruit-1-54-eink-display-breakouts.md)
- [Adafruit 2.13" eInk Display Breakouts and FeatherWings](https://learn.adafruit.com/adafruit-2-13-eink-display-breakouts-and-featherwings.md)
- [Adafruit 2.7" eInk Display Breakouts and Shields](https://learn.adafruit.com/adafruit-2-7-eink-display-breakouts-and-shields.md)
- [ePaper FeatherWing Quote Display](https://learn.adafruit.com/epaper-display-featherwing-quote-display.md)
- [ePaper Maze Maker](https://learn.adafruit.com/epaper-maze-maker.md)
- [Quickstart using Adafruit eInk/ePaper displays with CircuitPython](https://learn.adafruit.com/quickstart-using-adafruit-eink-epaper-displays-with-circuitpython.md)
- [Raspberry Pi E-Ink Weather Station using Python](https://learn.adafruit.com/raspberry-pi-e-ink-weather-station-using-python.md)
- [ePaper Calendar Featuring Metro M4 Express Airlift and Tri-Color ePaper Shield](https://learn.adafruit.com/epaper-calendar-featuring-metro-m4-express-airlift-and-epaper-shield.md)
- [QT Py CH32V203 eInk / ePaper Daily Calendar and Clock](https://learn.adafruit.com/ch32v203-eink-epaper-calendar-and-clock.md)
- [eInk FeatherWing Display Stand](https://learn.adafruit.com/eink-featherwing-display-stand.md)
- [Raspberry Pi E-Ink Event Calendar using Python](https://learn.adafruit.com/raspberry-pi-e-ink-desk-calendar-using-python.md)
- [eInk / ePaper Weather Station](https://learn.adafruit.com/epaper-weather-station.md)
- [Tiny Autostereogram Construction Kit](https://learn.adafruit.com/tiny-autostereogram-construction-kit.md)
- [Ladyada's Toolkit](https://learn.adafruit.com/ladyadas-toolkit.md)
- [Glowing Scale Armor](https://learn.adafruit.com/glowing-scale-armor.md)