# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## Overview
The Pixel Framebuf library makes drawing to a grid of NeoPixels or DotStars as easy as writing to a display. The library has all of the drawing functions of the original framebuf library, including the ability to draw lines, circles, rectangles, and text.
This library can be used on a wide variety of NeoPixel and DotStar LED layouts including with flexible and non-flexible matrices, NeoPixels strips laid out by hand, or FeatherWings. This library has been tested to work with both CircuitPython Microcontrollers and Blinka on the Raspberry Pi.
One of the huge advantages that using NeoPixel and DotStar LED matrices has over the standard RGB LED matrices is that they only use one or two GPIO pins. The Pixel Framebuf library gives you the simplicity and control to make use of these matrices to display data in a meaningful way in much the same way that you can on RGB matrices.
## Parts
Here are a few of many products that this library supports:
### Flexible 16x16 NeoPixel RGB LED Matrix
[Flexible 16x16 NeoPixel RGB LED Matrix](https://www.adafruit.com/product/2547)
For advanced NeoPixel fans, we now have a bendable, **Flexible 16x16 NeoPixel LED Matrix**! Control all 256 ultra-bright LEDs using a single microcontroller pin, set each LED as you wish to scroll messages or draw little images. This matrix has a thick flexible PCB backing that...
In Stock
[Buy Now](https://www.adafruit.com/product/2547)
[Related Guides to the Product](https://learn.adafruit.com/products/2547/guides)
### Adafruit NeoPixel LED Strip Starter Pack - 30 LED meter - Black
[Adafruit NeoPixel LED Strip Starter Pack - 30 LED meter - Black](https://www.adafruit.com/product/2562)
You can't bake a cake without flour, sugar, and baking soda? Cream cheese? Muscadet? Ok - to be honest we don't do much cake baking. But we do light up a TON of NeoPixel LED strips! They're everywhere - from our
Out of Stock
[Buy Now](https://www.adafruit.com/product/2562)
[Related Guides to the Product](https://learn.adafruit.com/products/2562/guides)
NeoPixels take a lot of power, so a 5V 4 Amp or even a 10 Amp power supply is recommended.
### 5V 4A (4000mA) switching power supply - UL Listed
[5V 4A (4000mA) switching power supply - UL Listed](https://www.adafruit.com/product/1466)
Need a lot of 5V power? This switching supply gives a clean regulated 5V output at up to **4 Amps** (4000mA). 110 or 240 input, so it works in any country. The plugs are "US 2-prong" style so you may need a plug adapter, but you can pick one up at any hardware store for $1 or so,...
In Stock
[Buy Now](https://www.adafruit.com/product/1466)
[Related Guides to the Product](https://learn.adafruit.com/products/1466/guides)
### 5V 10A switching power supply
[5V 10A switching power supply](https://www.adafruit.com/product/658)
This is a beefy switching supply, for when you need a lot of power! It can supply 5V DC up to 10 Amps, running from 110V or 220V power (the plug it comes with is for US/Canada/Japan but you can use any plug adapter for your country, or just replace the cable with a standard computer/appliance...
In Stock
[Buy Now](https://www.adafruit.com/product/658)
[Related Guides to the Product](https://learn.adafruit.com/products/658/guides)
# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## Wiring
To make wiring simple, we recommend a couple of different products available in our store. First we recommend a DC Power jack with terminals so it's easy to connect up to an external power supply.
### Female DC Power adapter - 2.1mm jack to screw terminal block
[Female DC Power adapter - 2.1mm jack to screw terminal block](https://www.adafruit.com/product/368)
If you need to connect a DC power wall wart to a board that doesn't have a DC jack - this adapter will come in very handy! There is a 2.1mm DC jack on one end, and a screw terminal block on the other. The terminals are labeled with positive/negative assuming a positive-tip configuration...
In Stock
[Buy Now](https://www.adafruit.com/product/368)
[Related Guides to the Product](https://learn.adafruit.com/products/368/guides)
The other product that makes it easy if you have one of our NeoPixel Matrices is a 2-wire JST SM connector so you can use the the data line without cutting anything:
### 2-pin JST SM Plug + Receptacle Cable Set
[2-pin JST SM Plug + Receptacle Cable Set](https://www.adafruit.com/product/2880)
These 2-wire cables are 16cm long and come as a set. One side has a 2-pin JST SM type connector plug on the end. The other side has a matching 2-pin JST SM type receptacle connector. They are good for whenever you have 2 wires you want to be able to plug and unplug....
In Stock
[Buy Now](https://www.adafruit.com/product/2880)
[Related Guides to the Product](https://learn.adafruit.com/products/2880/guides)
Likewise, if you have one of our DotStar Matrices, we have a 4-wire version as well:
### 4-pin JST SM Plug + Receptacle Cable Set
[4-pin JST SM Plug + Receptacle Cable Set](https://www.adafruit.com/product/578)
These 4-wire cables are 15cm long and come as a set, one side has a JST SM type connector plug on the end. The other side has a matching JST SM type receptacle connector. They are good for whenever you have 4 wires you want to be able to plug and unplug. We like the solid and compact nature of...
In Stock
[Buy Now](https://www.adafruit.com/product/578)
[Related Guides to the Product](https://learn.adafruit.com/products/578/guides)
Another easy option to connect NeoPixels is to use some Jumper Wires:
### Premium Female/Male 'Extension' Jumper Wires - 40 x 6" (150mm)
[Premium Female/Male 'Extension' Jumper Wires - 40 x 6" (150mm)](https://www.adafruit.com/product/826)
Handy for making wire harnesses or jumpering between headers on PCB's. These premium jumper wires are 6" (150mm) long and come in a 'strip' of 40 (4 pieces of each of ten rainbow colors). They have 0.1" male header contacts on one end and 0.1" female header contacts...
Out of Stock
[Buy Now](https://www.adafruit.com/product/826)
[Related Guides to the Product](https://learn.adafruit.com/products/826/guides)
## NeoPixel Matrix Wiring
Wiring the pixels up to either a Microcontroller running CircuitPython or a Raspberry Pi running Blinka is very easy since either one only uses a single GPIO pin. Adafruit matrices come wired with separate power wires and data lines which makes it really easy to connect.
### CircuitPython Wiring
It is recommended using a microcontroller with an M4 processor, because it can drive a lot of NeoPixels fast and doesn't cost much more than an M0 board.
To connect it, you will need to wire it as follows:
- Connect the **red wire** to **+5V** on the power supply.
- Connect the **black wire** to **Ground** on the power supply
- Connect the **white DIN wire** of the female JST connector to **D6** on the Microcontroller
- Connect the **black wire** of the female JST connector to **Ground** on the Microcontroller
[Download Fritzing Object](https://cdn-learn.adafruit.com/assets/assets/000/094/822/original/Metro_Wiring.fzz?1600451126)
### Raspberry Pi Wiring
Raspberry Pi boards are powerful enough to drive lots of NeoPixels, but you will need to connect it to **GPIO10, GPIO12, GPIO18 or GPIO21** to work! We recommend GPIO18, which is Pin 12 on the 40-pin header.
To connect it, you will need to wire it as follows:
- Connect the **red wire** to **+5V** on the power supply.
- Connect the **black wire** to **Ground** on the power supply
- Connect the **white wire** of the JST connector to **GPIO18** (Pin 12) on the Microcontroller
- Connect the **black wire** of the JST connector to **Ground** (Pin 6) on the Microcontroller
[Download Fritzing Object](https://cdn-learn.adafruit.com/assets/assets/000/094/826/original/Pi_Wiring.fzz?1600452405)
For more information on wiring other configurations, be sure to check out our [Adafruit NeoPixel Überguide](https://learn.adafruit.com/adafruit-neopixel-uberguide).
## DotStar Wiring
Wiring the DotStar matrix up will only take up two GPIO pins. Adafruit matrices come wired with separate power wires and a connector with the power, data, and clock lines in a single connector, which makes them easy to chain together. For a very in-depth guide on DotStars and wiring them up in various configurations, be sure to checkout the [Adafruit DotStar LEDs](https://learn.adafruit.com/adafruit-dotstar-leds) guide.
# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## Import and Setup
The Pixel Framebuf library is designed to make adding text and graphics super simple. It is built on top of the very capable LED Animation and framebuf libraries and because of the flexibility provided by those libraries, it works on a wide variety of NeoPixel and DotMatrix displays and layouts.
## CircuitPython Setup
To get the required libraries for this guide, download the latest CircuitPython library bundle from circuitpython.org.
[Download the latest CircuitPython library bundle](https://circuitpython.org/libraries)
Open the downloaded zip and find the following folder and files within the **lib** folder:
- **adafruit\_pixel\_framebuf.mpy**
- **adafruit\_framebuf.mpy**
- **adafruit\_led\_animation**
If you are using NeoPixels, you will also need:
- **neopixel.mpy**
Or if you are using DotStar LEDs, you will need:
- **adafruit\_dotstar.mpy**
Drag this folder and files to the **lib** folder on your **CIRCUITPY** drive.
## Python Setup
You'll need to install the Adafruit\_Blinka library that provides the CircuitPython support in Python. This may also require enabling I2C 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)!
Run NeoPixels on the Raspberry Pi requires the **sudo** command, so you will need to make sure you have the necessary libraries installed using `sudo pip3`.
Since Pip does a great job of handling dependencies, there's only a few commands you will need to run to get this set up:
- `sudo pip3 install adafruit-circuitpython-pixel-framebuf`
If you are running NeoPixels, you will also need the NeoPixel library:
- `sudo pip3 install adafruit-circuitpython-neopixel`
If you are running DotStars, you will also need the DotStar library:
- `sudo pip3 install adafruit-circuitpython-dotstar`
You will also need the Pillow library if you want to make use of the `image()` function:
- `sudo pip3 install Pillow`
Raspberry Pi requires a hardware PWM pin to drive the NeoPixels. We recommend D18, so you will need to change that in the code below if you any place you see D6.
## Font File
If you want to display text, you will also need to include the font file. This font is included in the **adafruit\_framebuf** library examples.
[Download font5x8.bin](https://github.com/adafruit/Adafruit_CircuitPython_framebuf/raw/main/examples/font5x8.bin)
Place the font file in the same folder as you code.
## Import and Object Setup
This library should work with either NeoPixels or DotStar LEDs. We are going to start by showing you how to use them with NeoPixels.
### NeoPixels
The first thing you will need to do to run this library is to import the necessary libraries. An example of import and setup for the NeoPixel FeatherWing is as follows:
```python
import board
import neopixel
from adafruit_pixel_framebuf import PixelFramebuffer
pixel_pin = board.D6
pixel_width = 8
pixel_height = 4
pixels = neopixel.NeoPixel(
pixel_pin,
pixel_width * pixel_height,
brightness=0.1,
auto_write=False,
)
```
First you import `board` and `neopixel`. Next import the `PixelFramebuffer` module. On certain NeoPixel displays, you may also need to import `VERTICAL` as well, which we'll cover in the **Initialization** section.
Next you'll want to set a few convenience variables including the `pixel_pin`, which is the pin that the NeoPixel data line is connected to. The `pixel_width` and `pixel_height` are there to help make the code more readable and correspond to the number of pixels wide and number of pixels high.
Finally, create the pixel object. You'll want to make sure `auto_write` is set to `False` so you don't see every single time an individual pixel is changed, which can be quite slow.
This guide will use NeoPixels for all the examples, but the Pixel Framebuf library works equally well with DotStar LEDs.
### DotStar LEDs
The only change you would need to make to use this library with DotStar LEDs would be to initialize the DotStar library instead of the NeoPixel library. An example of import and setup for the DotStar FeatherWing is as follows:
```python
import board
import adafruit_dotstar
from adafruit_pixel_framebuf import PixelFramebuffer
pixel_pin = board.D6
pixel_width = 12
pixel_height = 6
pixels = adafruit_dotstar.DotStar(
board.D13,
board.D11,
pixel_width * pixel_height,
brightness=0.3,
auto_write=False,
)
```
This example imports the necessary modules and assigns the appropriate pins and number of pixels to use 72 DotStar LEDs connected to D13 and D11.
# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## Usage
Using the Pixel Framebuf library is easy. The most complicated part of it is the initialization, because it can vary so widely with each specific setup, so start with that and then go over each of the functions available to you.
## Initialization
For initialization, we'll go over the different options and what the specific parameters mean so you can best determine which options to change for your setup.
- `pixels` - (required) The NeoPixels or DotStars object that you initialized
- `width` - (required) The width of the framebuf in pixels.
- `height` - (required) The height of the framebuf in pixels.
- `orientation` - The direction that the pixels are physically laid out in either columns or rows. The value is `HORIZONTAL` by default and you will need to import `VERTICAL` if you want to set the value to `VERTICAL`.
- `alternating` - If the pixels zigzag, you will want to set this to **True**. If they are laid out in the same direction, you will want to set this to **False**. The default value is **True**.
- `reverse_x` - Set this to **True** if you want to reverse the direction of all pixels horizontally.
- `reverse_y` - Set this to **True** if you want to reverse the direction of all pixels vertically.
- `top` - An optional tuple representing the top left pixel.
- `bottom` - An optional tuple representing the bottom right pixel.
- `rotation` - A value between 0 and 3 representing the initial rotation of the Framebuffer. This can also be set later with the `rotation` property.
## Example Initializations
Here are the initializations for a few of the panels we have available. In these examples, it is assumed that you have done the necessary imports and setup as described on the **Import and Setup** page and that your NeoPixels or DotStars are named `pixels`.
### 32x8 Panel
```python
pixel_framebuf = PixelFramebuffer(
pixels,
32,
8,
orientation=VERTICAL,
rotation=2
)
```
### 16x16 Panel
```python
pixel_framebuf = PixelFramebuffer(
pixels,
16,
16,
reverse_x=True,
)
```
### NeoPixel FeatherWing
```python
pixel_framebuf = PixelFramebuffer(
pixels,
8,
4,
alternating=False,
)
```
### DotStar FeatherWing
```python
pixel_framebuf = PixelFramebuffer(
pixels,
12,
6,
alternating=False,
)
```
## Drawing Functions
All drawing functions are based on coordinates starting from the upper left-hand side as the starting point.
Warning:
### Displaying the Framebuffer
Each time you want to display the current Framebuffer, you will need to call the `display()` function. This function takes no parameters and displays whatever is currently in memory. We will show you how to use it in each of the drawing function example code snippets.
### Fill
To fill in the entire Framebuffer with a specific color, you can use the `fill()` function. For instance, to fill it with Blue (`0x0000FF`), you would use the following command:
```python
pixel_framebuf.fill(0x0000FF)
pixel_framebuf.display()
```
To turn all the pixels off, you can set them to `0x000000.`
```python
pixel_framebuf.fill(0x000000)
pixel_framebuf.display()
```
### Pixel Drawing
To draw a pixel, you just need to use the `pixel()` function and provide the coordinates and color. For instance, if you wanted to draw a set the pixel at (4, 6) to red, you would use the following command:
```python
pixel_framebuf.pixel(4, 6, 0xFF0000)
pixel_framebuf.display()
```
If you wanted to get the pixel's value, you would retrieve it like this:
```python
color = pixel_framebuf.pixel(4, 6)
```
### Line Drawing
To draw a line, you just need to to use the `line()` function and provide the starting coordinates, ending coordinates, and color. For instance, if you wanted to draw a line from (0, 0) to (7, 9) in red (`0xFF0000`), you would use the following command:
```python
pixel_framebuf.line(0, 0, 7, 9, 0xFF0000)
pixel_framebuf.display()
```
### Horizontal and Vertical Line Drawing
To draw horizontal or vertical, you can use the `hline()` and `vline()` functions. These are optimized for fast drawing because they don't need to calculate a slope. You just need to pass the x and y coordinates along with the length of the line in pixels and the color you wish to draw.
To use these functions, to draw a 5 pixel red line starting at (2, 3), you would use the following:
```python
pixel_framebuf.hline(2, 3, 5, 0xFF0000)
pixel_framebuf.vline(2, 3, 5, 0xFF0000)
pixel_framebuf.display()
```
### Rectangle Drawing
To draw a non-filled Rectangle, you will want to use the `rect()` function. You provide it starting coordinates, width, height, and line color. To draw a red rectangle at (2, 2) with a width of 8 and a height of 12, you would use:
```python
pixel_framebuf.rect(2, 2, 8, 12, 0xFF0000)
pixel_framebuf.display()
```
To draw a filled rectangle, you would do the same thing with the `fill_rect()` function:
```python
pixel_framebuf.fill_rect(2, 2, 8, 12, 0xFF0000)
pixel_framebuf.display()
```
### Text Drawing
To draw text, you would use the `text()` function, provide the string, upper left coordinates of the text, and the color. For instance, to draw "Hi" at (3, 4) in green (`0x00FF00`), you would use the following:
```python
pixel_framebuf.text("Hi", 3, 4, 0x00FF00)
pixel_framebuf.display()
```
Text can go off the screen and simply redrawing the text in different positions on top of the same background can produce an animated text effect.
# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## Image Drawing with Python
If you are using CPython on Linux, you can also make use of the Pillow library and the image function to draw images to the display. The only limitations are the image needs to be the exact same size as the Framebuffer and needs to be in RGB mode.
We're going to go over an example for running this. First download the **blinka\_16x16.png** image and upload it to the folder that you plan to run the script in.
[Download blinka_16x16.png](https://raw.githubusercontent.com/adafruit/Adafruit_CircuitPython_Pixel_Framebuf/main/examples/blinka_16x16.png)
Next download the **pixel\_framebuf\_pillow\_image.py** example, which is available in the Library repo:
https://github.com/adafruit/Adafruit_CircuitPython_Pixel_Framebuf/blob/main/examples/pixel_framebuf_pillow_image.py
Run the code.
- `sudo python3 pixel_framebuf_pillow_image.py`
You should see an output similar to below:
## How It Works
Below describes what is going on. You may recognize much of it from the previous section.
First start with imports. In addition to the usual imports, also import `Image` from the Pillow library.
```python
import board
import neopixel
from PIL import Image
from adafruit_pixel_framebuf import PixelFramebuffer
```
After that, set up the object, except it's using D18 in this case. You can find more details about this earlier in this guide.
```python
pixel_pin = board.D18
pixel_width = 16
pixel_height = 16
pixels = neopixel.NeoPixel(
pixel_pin, pixel_width * pixel_height, brightness=0.1, auto_write=False,
)
pixel_framebuf = PixelFramebuffer(pixels, pixel_width, pixel_height, reverse_x=True,)
```
Next use Pillow to create a background and `alpha_composite()` the image onto it. The reason to do it this way is because the adafruit\_framebuf library requires the image to be in RGB format and if you directly you use `convert()` in Pillow, it will convert all transparencies to white. It's easier to see with a darker background.
Start off by creating a new image in **RGBA** mode. **RGBA** mode is required to use the `alpha_composite()` function. The default color is black, so you don't need to specify a color to use by default, although you certainly could.
```python
image = Image.new("RGBA", (pixel_width, pixel_height))
```
Next open the icon file.
```python
icon = Image.open("blinka_16x16.png")
```
Next use the `alpha_composite()` function to blend the icon onto the black background.
```python
image.alpha_composite(icon)
```
Finally, convert the combined image to RGB right before passing it to the `image()` function and then display it.
```python
pixel_framebuf.image(image.convert("RGB"))
pixel_framebuf.display()
```
That's it. It should display onto the NeoPixels.
# Easy NeoPixel Graphics with the CircuitPython Pixel Framebuf Library
## API Documentation
## Featured Products
### Flexible 16x16 NeoPixel RGB LED Matrix
[Flexible 16x16 NeoPixel RGB LED Matrix](https://www.adafruit.com/product/2547)
For advanced NeoPixel fans, we now have a bendable, **Flexible 16x16 NeoPixel LED Matrix**! Control all 256 ultra-bright LEDs using a single microcontroller pin, set each LED as you wish to scroll messages or draw little images. This matrix has a thick flexible PCB backing that...
In Stock
[Buy Now](https://www.adafruit.com/product/2547)
[Related Guides to the Product](https://learn.adafruit.com/products/2547/guides)
### Flexible 8x32 NeoPixel RGB LED Matrix
[Flexible 8x32 NeoPixel RGB LED Matrix](https://www.adafruit.com/product/2294)
For advanced NeoPixel fans, we how have a bendable, flexible 8x32 NeoPixel LED Matrix! Control all 256 ultra-bright LEDs using a single microcontroller pin, set each LED as you wish to scroll messages or draw little images. This matrix has a thick flexible PCB backing that can be...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2294)
[Related Guides to the Product](https://learn.adafruit.com/products/2294/guides)
### Flexible Adafruit DotStar Matrix 8x32 - 256 RGB LED Pixels
[Flexible Adafruit DotStar Matrix 8x32 - 256 RGB LED Pixels](https://www.adafruit.com/product/2736)
For advanced DotStar fans, we how have a bendable, flexible 8x32 DotStar LED Matrix! Control all 256 ultra-bright LEDs using only 2 microcontroller pins, set each LED as you wish to scroll messages or draw little images. This matrix has a thick flexible PCB backing that can be **gently...**
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2736)
[Related Guides to the Product](https://learn.adafruit.com/products/2736/guides)
### Flexible Adafruit DotStar Matrix 16x16 - 256 RGB LED Pixels
[Flexible Adafruit DotStar Matrix 16x16 - 256 RGB LED Pixels](https://www.adafruit.com/product/2735)
For advanced DotStar LED fans, we now have a bendable, **Flexible 16x16 Dotstar LED Matrix**! Control all 256 ultra-bright LEDs using only two microcontroller pins, set each LED as you wish to scroll messages or draw little images. This matrix has a thick flexible PCB backing that...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2735)
[Related Guides to the Product](https://learn.adafruit.com/products/2735/guides)
### Flexible Adafruit DotStar Matrix 8x8 - 64 RGB LED Pixels
[Flexible Adafruit DotStar Matrix 8x8 - 64 RGB LED Pixels](https://www.adafruit.com/product/2734)
Put on your sunglasses before wiring up this LED matrix - 64 eye-blistering RGB LEDs adorn the **Adafruit DotStar Matrix** for a blast of configurable color. Arranged in an 8x8 matrix, each pixel is individually addressable. Only one microcontroller pin is required to control...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2734)
[Related Guides to the Product](https://learn.adafruit.com/products/2734/guides)
### Adafruit NeoPixel NeoMatrix 8x8 - 64 RGB LED Pixel Matrix
[Adafruit NeoPixel NeoMatrix 8x8 - 64 RGB LED Pixel Matrix](https://www.adafruit.com/product/1487)
Put on your sunglasses before wiring up this LED matrix - 64 eye-blistering RGB LEDs adorn the NeoMatrix for a blast of configurable color. Arranged in an 8x8 matrix, each pixel is individually addressable. Only one microcontroller pin is required to control all the LEDs, and you get 24 bit...
In Stock
[Buy Now](https://www.adafruit.com/product/1487)
[Related Guides to the Product](https://learn.adafruit.com/products/1487/guides)
### Adafruit DotStar FeatherWing - 6 x 12 RGB LEDs
[Adafruit DotStar FeatherWing - 6 x 12 RGB LEDs](https://www.adafruit.com/product/3449)
A Feather board without ambition is a Feather board without FeatherWings! This is the **DotStar FeatherWing, a 6x12 RGB LED Add-on For All Feather Boards**! Using our [Feather Stacking Headers](https://www.adafruit.com/products/2830) or
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/3449)
[Related Guides to the Product](https://learn.adafruit.com/products/3449/guides)
### NeoPixel FeatherWing - 4x8 RGB LED Add-on For All Feather Boards
[NeoPixel FeatherWing - 4x8 RGB LED Add-on For All Feather Boards](https://www.adafruit.com/product/2945)
A Feather board without ambition is a Feather board without FeatherWings! This is the **NeoPixel FeatherWing, a 4x8 RGB LED Add-on For All Feather Boards**! Using our [Feather Stacking Headers](https://www.adafruit.com/products/2830) or
In Stock
[Buy Now](https://www.adafruit.com/product/2945)
[Related Guides to the Product](https://learn.adafruit.com/products/2945/guides)
## Related Guides
- [Adafruit NeoPixel FeatherWing](https://learn.adafruit.com/adafruit-neopixel-featherwing.md)
- [MicroPython Displays: Drawing Shapes](https://learn.adafruit.com/micropython-displays-drawing-shapes.md)
- [NeoPixels on Raspberry Pi](https://learn.adafruit.com/neopixels-on-raspberry-pi.md)
- [Adafruit NeoPixel Überguide](https://learn.adafruit.com/adafruit-neopixel-uberguide.md)
- [Remote Effects Trigger Box](https://learn.adafruit.com/remote-effects-trigger.md)
- [Easy Alexa (Echo) Control of your ESP8266 Huzzah](https://learn.adafruit.com/easy-alexa-or-echo-control-of-your-esp8266-huzzah.md)
- [Creating Custom LED Animations](https://learn.adafruit.com/creating-custom-led-animations.md)
- [Multi-tasking the Arduino - Part 3](https://learn.adafruit.com/multi-tasking-the-arduino-part-3.md)
- [Smart Bathroom App](https://learn.adafruit.com/smart-bathroom-app.md)
- [Sipping Power With NeoPixels](https://learn.adafruit.com/sipping-power-with-neopixels.md)
- [MicroPython Displays: Drawing Text](https://learn.adafruit.com/micropython-displays-drawing-text.md)
- [Using NeoPixels with Netduino Plus 2](https://learn.adafruit.com/using-neopixels-with-netduino.md)
- [Festive Feather Holiday Lights](https://learn.adafruit.com/festive-feather-holiday-lights.md)
- [CircuitPython LED Animations](https://learn.adafruit.com/circuitpython-led-animations.md)
- [Set up Web Workflow on the Adafruit MEMENTO](https://learn.adafruit.com/set-up-web-workflow-on-the-adafruit-memento.md)