# Adafruit 8x16 LED Matrix FeatherWing

## Overview

![](https://cdn-learn.adafruit.com/assets/assets/000/032/512/medium800/feather_3149-04.jpg?1463544274)

You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED matrix has, but bite sized! Double them up for 128 total bright LEDs.

We have these combo packs in [White](https://www.adafruit.com/products/3149), [Blue](https://www.adafruit.com/product/3150), [Green](https://www.adafruit.com/product/3151), [Red](https://www.adafruit.com/product/3152), [Yellow](https://www.adafruit.com/product/3153), and [Yellow-Green](https://www.adafruit.com/product/3154).

![](https://cdn-learn.adafruit.com/assets/assets/000/032/559/medium800thumb/feather_LEDMatrixWingGifRed.jpg?1463766209)

Normally, wiring up 8x16 matrices would require a breath-taking 24 GPIO pins, which is way too many pins. That's where this lovely 16x8 LED matrix backpack PCB comes in. It contains a HT16K33 I2C LED matrix driver that does all the multiplexing work for you, and is controlled over the two I2C pins. It's easy to use, has a portable library that runs on any of our Feathers to turn on/off each LED.

![](https://cdn-learn.adafruit.com/assets/assets/000/032/514/medium800/feather_3149-02.jpg?1463544290)

The 16x8 backpack is also great for making scrolling displays or small video displays.  In our example, we set it up to display small bitmap emoticons but you can also display text that moves - kind of like a sign in front of a miniature car dealership.

![](https://cdn-learn.adafruit.com/assets/assets/000/032/513/medium800/feather_3149-01.jpg?1463544281)

 This kit comes with:

- A fully tested and assembled 16x8 0.8" LED FeatherWing 
- 2 x ultra-bright square 8x8 matrices
- 2 x 16-pin header

A bit of soldering is required to attach the two matrices onto the FeatherWing but its very easy to do and only takes about 15 minutes.

# Adafruit 8x16 LED Matrix FeatherWing

## Pinouts

![](https://cdn-learn.adafruit.com/assets/assets/000/032/516/medium800/feather_pin2.jpg?1463544426)

![](https://cdn-learn.adafruit.com/assets/assets/000/032/515/medium800/feather_pinout.jpg?1463544378)

The 8x16 backpack makes it really easy to add a 128-LED display

The LEDs themselves do not connect to the Feather. Instead, a matrix driver chip (HT16K33) does the multiplexing for you. The Feather simply sends i2c commands to the chip to tell it what LEDs to light up and it is handled for you. This takes a lot of the work and pin-requirements off the Feather. Since it uses only I2C for control, it works with any Feather and can share the I2C pins for other sensors or displays.

# Power Pins
![](https://cdn-learn.adafruit.com/assets/assets/000/033/721/medium800/feather_powerpins.jpg?1468289101)

The LED matrix uses only the **3V** and **GND** pins for power and logic. Current draw depends on how many LEDs are lit but you can approximate it as about 120mA for most uses.

Note that the 3.3V power supply is a tiny bit lower than the forward voltage for the pure green, blue and white LED matrices but we didn't find any significant degredation in brightness. Really, they're still very bright.

# I2C pins
![](https://cdn-learn.adafruit.com/assets/assets/000/033/722/medium800/feather_i2c.jpg?1468289127)

All LED control is done over I2C using the HT16K33 interface library. This means SDA and SCL must be connected, see above for those pins.

The default address is **0x70** but you can change the address to **0x71-0x77** by bridging solder onto the address pins.

# Address Jumpers
![](https://cdn-learn.adafruit.com/assets/assets/000/032/519/medium800/feather_jumpz.jpg?1463544596)

## Changing Addresses

You can change the address of a backpack very easily. Look on the back to find the two or three **A0, A1 or A2** solder jumpers. Each one of these is used to hardcode in the address. If a jumper is shorted with solder, that sets the address. **A0** sets the lowest bit with a value of **1** , **A1** sets the middle bit with a value of **2** and **A2** sets the high bit with a value of **4**. The final address is **0x70 + A2 + A1 + A0**. So for example if **A2** is shorted and **A0** is shorted, the address is **0x70 + 4 + 1 = 0x75.** If only A1 is shorted, the address is **0x70 + 2 = 0x72**

# Adafruit 8x16 LED Matrix FeatherWing

## Assembly

When you buy a pack from Adafruit, it comes with the fully tested and assembled backpack as well as a two 8x8 dual displays in one of the colors we provide (say, red, yellow, blue or green). You'll need to solder the matrix onto the backpack but it's an easy task.

![feather_3149-01.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/520/medium640/feather_3149-01.jpg?1463544629)

## Prepare the header strips:

You'll need a 12-pin and 16-pin long strip of header to attach the Featherwing to your Feather. Cut the header strip to length if necessary. It will be easier to solder if you insert it into a breadboard - **long pins down**

![feather_header.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/521/medium640/feather_header.jpg?1463545327)

## Add the FeatherWing PCB:

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

![feather_place.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/522/medium640/feather_place.jpg?1463545340)

## And Solder!

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

![feather_solder1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/523/medium640/feather_solder1.jpg?1463545366)

![feather_solder2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/524/medium640/feather_solder2.jpg?1463545377)

![feather_solder3.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/525/medium640/feather_solder3.jpg?1463545413)

Do both header strips, all pins!

![feather_solder4.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/526/medium640/feather_solder4.jpg?1463545435)

![feather_solder6.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/528/medium640/feather_solder6.jpg?1463545461)

![feather_solder5.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/529/medium640/feather_solder5.jpg?1463545465)

Check your solder joints visually and continue onto the next step

![feather_soldered.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/530/medium640/feather_soldered.jpg?1463545484)

Next we'll attach the LED matrices  
Check the Matrices and line it up next to the FeatherWing

Look for the text on the matrices. This is the 'pin 1' side, and lines up with the same side as the side with the filled in white dot on the PCB silkscreen.

![feather_matrices.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/531/medium640/feather_matrices.jpg?1463545499)

![feather_matplace.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/532/medium640/feather_matplace.jpg?1463545553)

There's a little 'play' in the LED matrices to make it easy to solder them in place. It isn't noticable when they're lit but if you want to make sure there's no gap between the matrices, use some tape to bind them together while soldering

![feather_mattape.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/533/medium640/feather_mattape.jpg?1463545640)

![feather_mattaped.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/534/medium640/feather_mattaped.jpg?1463545643)

Solder the matrix in place. Note this will be a little tougher because there's not as much space. Go slow, do one pin at a time and you can clip it after each point if you need!

![feather_matsolder1.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/535/medium640/feather_matsolder1.jpg?1463545666)

![feather_masolder2.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/536/medium640/feather_masolder2.jpg?1463545680)

![feather_matsolder4.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/537/medium640/feather_matsolder4.jpg?1463545691)

![feather_matsolder5.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/538/medium640/feather_matsolder5.jpg?1463545695)

Check your solder joints visually and continue onto the next step

![feather_matsoldered.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/539/medium640/feather_matsoldered.jpg?1463545708)

Once soldered, clip each matrix wire short

![feather_clip.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/540/medium640/feather_clip.jpg?1463545717)

You're done! You can now install software and get blinking

![feather_done.jpg](https://cdn-learn.adafruit.com/assets/assets/000/032/541/medium640/feather_done.jpg?1463545739)

# Adafruit 8x16 LED Matrix FeatherWing

## Usage

![](https://cdn-learn.adafruit.com/assets/assets/000/032/545/medium800/feather_3149-04.jpg?1463701839)

To talk to the LED helper chip you'll need to use our Arduino [Adafruit LED Backpack library from github](https://github.com/adafruit/Adafruit-LED-Backpack-Library "Link: https://github.com/adafruit/Adafruit-LED-Backpack-Library").

To download you can visit the repository, or simply click on this button:

[Download Adafruit LED Backpack Library](https://github.com/adafruit/Adafruit_LED_Backpack/archive/master.zip)
Rename the uncompressed folder **Adafruit\_LEDBackpack**. Check that the **Adafruit\_LEDBackpack** folder contains **Adafruit\_LEDBackpack.cpp** and **Adafruit\_LEDBackpack.h** Place the **Adafruit\_LEDBackpack** library folder your _arduinosketchfolder_ **/libraries/** folder.

You may need to create the _libraries_ subfolder if it's your first library. We also have a great tutorial on Arduino library installation at:  
[http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use](http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use "Link: http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use")

# Install Adafruit GFX

[You will need to do the same for the Adafruit\_GFX library available here](https://github.com/adafruit/Adafruit-GFX-Library "Link: https://github.com/adafruit/Adafruit-GFX-Library")

[Download Adafruit GFX Library](https://github.com/adafruit/Adafruit-GFX-Library/archive/master.zip)
Rename the uncompressed folder **Adafruit\_GFX** and check that the **Adafruit\_GFX** folder contains **Adafruit\_GFX.**** cpp **and** Adafruit\_GFX ****.h**  
  
Place the  **Adafruit\_GFX** library folder your **_arduinosketchfolder_/libraries/** folder like you did with the LED Backpack library

If using an older version of the Arduino IDE (pre-1.8.10), also locate and install the [**Adafruit\_BusIO**](https://github.com/adafruit/Adafruit_BusIO/archive/master.zip) library (newer versions do this automatically when using the Arduino Library Manager).

# Run Test!

Once you've restarted you should be able to select the **File-\>Examples-\>Adafruit\_LEDBackpack-\>minimatrix16x8** example sketch. Upload it to your Feather as usual. You should see a basic test program that goes through a bunch of different routines.

![](https://cdn-learn.adafruit.com/assets/assets/000/032/546/medium800/feather_demo.png?1463702239)

Warning: 

Upload to your Arduino, and open up the Serial console at 9600 baud speed. You'll see a little light show demonstrating bitmaps, drawing lines, circles and squares, text scrolling and more!

# Library Reference

For the 16x8 displays, our library essentially treats it like a grpahical display with 128 pixels

## Setup

You can create the object with

```
Adafruit_8x16minimatrix matrix = Adafruit_8x16minimatrix();
```

There's no arguments or pins because the backpacks use the fixed I2C pins.  
By default, the address is 0x70, but you can pass in the I2C address used when you initialize the display with **begin**

```
matrix.begin(0x70);  // pass in the address
```

## Drawing with Adafruit GFX

Once you're happy that the matrix works, you can write your own sketches. The 16x8 matrix supports everything the Adafruit GFX library - drawing pixels, lines, rectangles, circles, triangles, roundrects, and small bitmaps. [For more details check out the GFX page which will detail all of the GFX routines](http://learn.adafruit.com/adafruit-gfx-graphics-library).

![](https://cdn-learn.adafruit.com/assets/assets/000/032/547/medium800/feather_char.png?1463703210)

## Writing Data

Don't forget to 'write' the data to the display with

```
matrix.writeDisplay();
```

That's what actually 'sets' the data onto the LEDs!

## Other things!

- **setBrightness(_brightness_)**- will let you change the overall brightness of the entire display. 0 is least bright, 15 is brightest and is what is initialized by the display when you start
- **blinkRate(_rate_)** - You can blink the entire display. 0 is no blinking. 1, 2 or 3 is for display blinking.

# Adafruit 8x16 LED Matrix FeatherWing

## CircuitPython

# Adafruit CircuitPython Module Install

To use the LED backpack with your [Adafruit CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/overview) board you'll need to install the [Adafruit\_CircuitPython\_HT16K33](https://github.com/adafruit/Adafruit_CircuitPython_HT16K33) module on your board.  **Remember this module is for Adafruit CircuitPython firmware and not MicroPython.org firmware!**

First make sure you are running the [latest version of Adafruit CircuitPython](https://github.com/adafruit/circuitpython/releases) for your board.  Next you'll need to install the necessary libraries to use the hardware--read below and carefully follow the referenced steps to find and install these libraries from [Adafruit's CircuitPython library bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle).

## Bundle Install

For express boards that have extra flash storage, like the Feather/Metro M0 express and Circuit Playground express, you can easily install the necessary libraries with [Adafruit's CircuitPython bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle).  This is an all-in-one package that includes the necessary libraries to use the LED backpack display with CircuitPython. For details on installing the bundle, read about [CircuitPython Libraries](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries).

Remember for non-express boards like the Trinket M0, Gemma M0, and Feather/Metro M0 basic you'll need to [manually install the necessary libraries](https://learn.adafruit.com/welcome-to-circuitpython/circuitpython-libraries#non-express-boards-11-13) from the bundle:

- **adafruit\_ht16k33**
- **adafruit\_bus\_device**
- **adafruit\_register**

If your board supports USB mass storage, like the M0-based boards, then simply drag the files to the board's file system. **Note on boards without external SPI flash, like a Feather M0 or Trinket/Gemma M0, you might run into issues on Mac OSX with hidden files taking up too much space when drag and drop copying, [see this page for a workaround](../../../../micropython-for-samd21/usb-mass-storage#mac-osx-file-copy-issues).**

If your board doesn't support USB mass storage, like the ESP8266, then [use a tool like ampy to copy the file to the board](../../../../micropython-basics-load-files-and-run-code). You can use the latest version of ampy and its [new directory copy command](../../../../micropython-basics-load-files-and-run-code/file-operations#copy-directories-to-board) to easily move module directories to the board.

Before continuing make sure your board's **lib** folder or root filesystem has at least the  **adafruit\_ht16k33** ,  **adafruit\_bus\_device** , and  **adafruit\_register**  folders/modules copied over.

![](https://cdn-learn.adafruit.com/assets/assets/000/046/333/medium800/micropython_Screen_Shot_2017-09-13_at_2.33.52_PM.png?1505338457)

# Usage

The following section will show how to control the LED backpack from the board's Python prompt / REPL.  You'll walk through how to control the LED display and learn how to use the CircuitPython module built for the display.

First [connect to the board's serial REPL ](https://learn.adafruit.com/welcome-to-circuitpython/the-repl)so you are at the CircuitPython  **\>\>\>**  prompt.

## I2C Initialization

First you'll need to initialize the I2C bus for your board.  First import the necessary modules:

```
import board
import busio as io
```

Note if you're using the ESP8266 or other boards which do not support hardware I2C you need to import from the bitbangio module instead of busio:

```
import board
import bitbangio as io
```

Now for either board run this command to create the I2C instance using the default SCL and SDA pins (which will be marked on the boards pins if using a Feather or similar Adafruit board):

```
i2c = io.I2C(board.SCL, board.SDA)
```

# LED Matrix

To use a LED matrix you'll first need to import the  **adafruit\_ht16k33.matrix**  module and create an instance of the appropriate Matrix class.  There are three classes currently available to use:

- **Matrix8x8**  - This is for a simple 8x8 matrix (square or round pixels, they're both the same driver and code).
- **Matrix16x8**  - This is for a 16x8 matrix (i.e. double the width of the 8x8 matrices).  For the LED Matrix FeatherWing you want to use this Matrix16x8 class.
- **Matrix8x8x2**  - This is for a 8x8 bi-color matrix.

For example to use the Matrix16x8 class import the module and create an instance with:

```
import adafruit_ht16k33.matrix 
matrix = adafruit_ht16k33.matrix.Matrix16x8(i2c)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/334/medium800/micropython_IMG_20170913_144507378.jpg?1505339572)

The above command will create the matrix class using the default I2C address of the display (0x70).  If you've changed the I2C address (like when using multiple backpacks or displays) you can override it in the initializer using an optional  **address**  keyword argument.

For example to create an instance of the Matrix8x8 class on address 0x74:

```
matrix = adafruit_ht16k33.matrix.Matrix8x8(i2c, address=0x74)
```

You might notice the matrix turns on to a 'jumbled' collection of random LEDs.  Don't worry!  The display isn't broken, right now the module that controls it doesn't clear the display state on startup so you might see noise from random memory values.

To clear the display and turn all the pixels off you can use the  **fill**  command with a color of 0 (off):

```
matrix.fill(0)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/335/medium800/micropython_IMG_20170913_144530499.jpg?1505339584)

By default the display will update automatically. This way you do not need to call the **show** function every time you update the display buffer. However, this means it is being sent the contents of the display buffer with every change. This can slow things down if you're trying to do something fancy. If you think you're running into that issue, you can simply turn the auto write feature off. Then you will need to call **show** to update the display.

```
# auto write can be turned off
matrix.auto_write = False
# and fill is same as before
matrix.fill(0)
# but now you have to call show()
matrix.show()
```

To turn all the pixels on you can use **fill** with a color of 1 (on):

```
matrix.fill(1)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/336/medium800/micropython_IMG_20170913_144542195.jpg?1505339595)

If you're using the bi-color matrix you can even use a fill color of 2 or 3 to change to different colors of red, green, and yellow (red + green).

Next you can set pixels on the display by accessing them using x,y coordinates and setting a color:

- **X position**  - X position of the pixel on the matrix.
- **Y position**  - Y position of the pixel on the matrix.
- **Color**  - 0 for off, 1 for on (or one of the LEDs for bi-color display), 2 or 3 for other bi-color display colors.

The general way to set a pixel is:

```
matrix[x,y] = color
```

For example to set the first pixel at position 0, 0 to on:

```
matrix[0, 0] = 1
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/337/medium800/micropython_IMG_20170913_144617377.jpg?1505339607)

Or to set the opposite corner pixel at position 7, 7 to on:

```
matrix[7, 7] = 1
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/338/medium800/micropython_IMG_20170913_144630045.jpg?1505339619)

That's all there is to controlling the pixels on a LED matrix!  Right now the matrix library is simple and only exposes basic pixel control.  In the future more advanced drawing commands might be avaialable.

## Brightness and Blinking

You can change the brightness of the entire display with the **brightness** property.  This property has a decimanl value from 0 to 1, where 0 is the lowest brightness and 1 is the highest brightness.  Note that you don't need to call **show** after calling **brightness** , the change is instant.

For example to set the brightness to the minimum:

```
matrix.brightness = 0
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/339/medium800/micropython_IMG_20170913_144648307.jpg?1505339634)

Or to set it back to maximum:

```auto
matrix.brightness = 1
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/340/medium800/micropython_IMG_20170913_144657638.jpg?1505339649)

To set brightness to half:

```python
matrix.brightness = 0.5
```

You can also make the entire display blink at 3 different rates using the  **blink\_rate** property, which has a value 0 to 3:

- **0**  = no blinking
- **1**  = fast blinking (~once a 1/2 second)
- **2**  = moderate blinking (~once a second)
- **3**  = slow blinking (~once every 2 seconds)

Again you don't need to call **show** after setting the blink rate, the change will immediately take effect.

For example to blink quickly:

```
matrix.blink_rate = 1
```

And to stop blinking:

```
matrix.blink_rate = 0
```

# LED 7-segment Display

To use a 7-segment display you'll first need to import the **adafruit\_ht16k33.segments**  module and create an instance of the  **Seg7x4**  class.

```
import adafruit_ht16k33.segments
display = adafruit_ht16k33.segments.Seg7x4(i2c)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/341/medium800/micropython_IMG_20170913_144031598.jpg?1505339662)

The above command will create the 7-segment class using the default I2C address of the display (0x70).  If you've changed the I2C address (like when using multiple backpacks or displays) you can override it in the initializer using an optional  **address**  keyword argument.

For example to create an instance of the **Seg7x4**  class on address 0x74:

```
display = adafruit_ht16k33.Seg7x4(i2c, address=0x74)
```

You might notice the display turns on to a 'jumbled' collection of random LEDs.  Don't worry!  The display isn't broken, right now the module that controls it doesn't clear the display state on startup so you might see noise from random memory values.

To clear the display and turn all the LEDs off you can use the  **fill**  command with a color of 0 (off):

```
display.fill(0)

```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/342/medium800/micropython_IMG_20170913_144106436.jpg?1505339676)

## Setting Individual Digits

You can put a numeric value in any of the display's 4 positions by accessing it using the index of the position.  For example to set position 0 to the number 1 and position 1 to the number 2 call:

```
display[0] = '1'
display[1] = '2'
display.show()
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/343/medium800/micropython_IMG_20170913_144135715.jpg?1505339686)

## Display Numbers and Hex Values

You can also use the **print** function to write to the entire display. Remember the display only has 4 digits so a best effort will be made to display the number--you might need to round the number or adjust it to fit!

```
display.print(1234)
display.show()
display.print(3.141)
display.show()
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/344/medium800/micropython_IMG_20170913_144202675.jpg?1505339699)

To display hex values, pass in a string to **print**. The hex characters A-F can be displayed.

```
display.print('FEED')
display.show()
```

If you want to work with actual integer values, then use the built in string formatting.

```
display.print('{:x}'.format(65261))
display.show()
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/345/medium800/micropython_IMG_20170913_144231327.jpg?1505339716)

You can pass some special characters to the display to control extra capabilities:

- **Colon**  - Use ':' to turn the colon on, you don't need to specify the position parameter.  Use ';' to turn the colon off.
- **Hex character**  - Use a character 'a' through 'f' to display a high hex character value at a specified position.

# LED 14-segment Quad Alphanumeric Display

To use a 14-segment quad alphanumeric display it's almost exactly the same as the 7-segment display, but with a slightly different class name.  Import the  **adafruit\_ht16k33.segments**  module again but this time create an instance of the  **Seg14x4**  class.

```
import adafruit_ht16k33.segments
display = adafruit_ht16k33.segments.Seg14x4(i2c)
```

The above command will create the 14-segment class using the default I2C address of the display (0x70).  If you've changed the I2C address (like when using multiple backpacks or displays) you can override it in the initializer using an optional  **address**  keyword argument.

For example to create an instance of the **Seg14x4**  class on address 0x74:

```
display = adafruit_ht16k33.segments.Seg14x4(i2c, address=0x74)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/346/medium800/micropython_IMG_20170913_155708729.jpg?1505346466)

You might notice the display turns on to a 'jumbled' collection of random LEDs.  Don't worry!  The display isn't broken, right now the module that controls it doesn't clear the display state on startup so you might see noise from random memory values.

To clear the display and turn all the LEDs off you can use the  **fill**  command with a color of 0 (off):

```
display.fill(0)
display.show()
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/347/medium800/micropython_IMG_20170913_155729464.jpg?1505346593)

To access the individual digits, it's the same as with the 7-segment display. However, the 14-segment display can take any alphanumeric character. For example:

```
display[0] = 'C'
display[1] = 'I'
display[2] = 'P'
display[3] = 'Y'
display.show() 
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/471/medium800/micropython_IMG_20170914_163845075.jpg?1505432490)

You can use the **print** function to write to the entire display.

```
display.print('CPY!')
display.show()
```

![](https://cdn-learn.adafruit.com/assets/assets/000/046/472/medium800/micropython_IMG_20170914_163935712.jpg?1505432509)

# Adafruit 8x16 LED Matrix FeatherWing

## Downloads

- [Arduino LED Backpack Library](https://github.com/adafruit/Adafruit_LED_Backpack)
- [EagleCAD Featherwing PCB files](https://github.com/adafruit/Adafruit-LED-Backpack-FeatherWing-PCB)
- [Fritzing objects in the Adafruit Fritzing library](https://github.com/adafruit/Fritzing-Library)

# Schematic

Click to embiggen

![](https://cdn-learn.adafruit.com/assets/assets/000/032/548/medium800/feather_schem.png?1463703909)

# Fabrication Print

Dimensions in Inches

![](https://cdn-learn.adafruit.com/assets/assets/000/032/549/medium800/feather_fabprint.png?1463703945)


## Featured Products

### Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Blue

[Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Blue](https://www.adafruit.com/product/3150)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED...

In Stock
[Buy Now](https://www.adafruit.com/product/3150)
[Related Guides to the Product](https://learn.adafruit.com/products/3150/guides)
### Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Green

[Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Green](https://www.adafruit.com/product/3151)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED...

In Stock
[Buy Now](https://www.adafruit.com/product/3151)
[Related Guides to the Product](https://learn.adafruit.com/products/3151/guides)
### Adafruit 0.8" 8x16 LED Matrix FeatherWing Display - Red

[Adafruit 0.8" 8x16 LED Matrix FeatherWing Display - Red](https://www.adafruit.com/product/3152)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED...

In Stock
[Buy Now](https://www.adafruit.com/product/3152)
[Related Guides to the Product](https://learn.adafruit.com/products/3152/guides)
### Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Yellow

[Adafruit 0.8" 8x16 LED Matrix FeatherWing Display Kit - Yellow](https://www.adafruit.com/product/3153)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED...

In Stock
[Buy Now](https://www.adafruit.com/product/3153)
[Related Guides to the Product](https://learn.adafruit.com/products/3153/guides)
### Adafruit 0.8" 8x16 LED Matrix FeatherWing Display - Yellow-Green

[Adafruit 0.8" 8x16 LED Matrix FeatherWing Display - Yellow-Green](https://www.adafruit.com/product/3154)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. This kit combines two of our adorable miniature LED matrices with a FeatherWing driver board. At 0.8" square, these little 8x8 matrices have got everything a big LED...

In Stock
[Buy Now](https://www.adafruit.com/product/3154)
[Related Guides to the Product](https://learn.adafruit.com/products/3154/guides)
### Adafruit 8x16 LED Matrix FeatherWing w/o Matrices

[Adafruit 8x16 LED Matrix FeatherWing w/o Matrices](https://www.adafruit.com/product/3090)
You will chirp with delight when you see how easy it is to make your very own 8x16 LED matrix display for any Feather. At 0.8" square, the little [8x8 matrices](https://www.adafruit.com/new/?q=8x8%20miniature%20LED%20matrix&) have everything a big LED matrix has,...

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

## Related Guides

- [Adafruit LED Backpacks](https://learn.adafruit.com/adafruit-led-backpack.md)
- [Adafruit PowerBoost 500 Shield](https://learn.adafruit.com/adafruit-powerboost-500-shield-rechargeable-battery-pack.md)
- [Adafruit SEN6x Breakout](https://learn.adafruit.com/adafruit-sen6x-breakout.md)
- [MPU6050 6-DoF Accelerometer and Gyro](https://learn.adafruit.com/mpu6050-6-dof-accelerometer-and-gyro.md)
- [Adafruit LSM6DS3TR-C 6-DoF Accel + Gyro IMU](https://learn.adafruit.com/adafruit-lsm6ds3tr-c-6-dof-accel-gyro-imu.md)
- [Adafruit ESP32-S2 TFT Feather](https://learn.adafruit.com/adafruit-esp32-s2-tft-feather.md)
- [WiFi Music Alert Box ](https://learn.adafruit.com/wifi-music-alert-box.md)
- [Adafruit PiCowbell Adalogger for Pico](https://learn.adafruit.com/adafruit-picowbell-adalogger-for-pico.md)
- [Adafruit QT Py ESP32-S2 and QT Py ESP32-S2 with uFL Antenna](https://learn.adafruit.com/adafruit-qt-py-esp32-s2.md)
- [LED Matrix Wall Arcade for Pico-8](https://learn.adafruit.com/led-matrix-wall-arcade.md)
- [Adafruit BrainCraft HAT - Easy Machine Learning for Raspberry Pi](https://learn.adafruit.com/adafruit-braincraft-hat-easy-machine-learning-for-raspberry-pi.md)
- [AFMotor Library Reference](https://learn.adafruit.com/afmotor-library-reference.md)
- [Adafruit Rotary Trinkey](https://learn.adafruit.com/adafruit-rotary-trinkey.md)
- [Adafruit ItsyBitsy ESP32](https://learn.adafruit.com/adafruit-itsybitsy-esp32.md)
- [Adafruit Metro M7 with microSD](https://learn.adafruit.com/adafruit-metro-m7-microsd.md)