# Adafruit NeoDriver - I2C to NeoPixel Driver

## Overview

![](https://cdn-learn.adafruit.com/assets/assets/000/121/502/medium800/adafruit_products_5766-05_1.gif?1685967980)

NeoPixel LEDs (a.k.a WS2812 / SK6812 family) are a super-easy way to add addressable RGB lighting with only one GPIO. They're ubiquitous on microcontrollers, but some chips or single board computers (SBCs) don't have NeoPixel support due to the precision timing required to send data.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/503/medium800/adafruit_products_5766-04.jpg?1685968022)

We often get folks asking how to get NeoPixels working on some OrangeBananaOnionRockchipAllWinner Pi type board, given we have our [Blinka library that provides support for CircuitPython libraries](https://learn.adafruit.com/adding-a-single-board-computer-to-blinka) including the NeoPixel library. But if there's no **neopixel\_write** implementation written for that platform, it just won't work. And writing the NeoPixel-writer function is non-trivial on many chips: you really need fast GPIO and nanosecond-perfect timing.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/504/medium800/adafruit_products_5766-03.jpg?1685968112)

A quick solution is this seesaw-based NeoDriver board here: [send it the NeoPixel data you want to write over I2C](https://learn.adafruit.com/adafruit-seesaw-atsamd09-breakout/neopixel) and it will blit out the perfect pixel timing on the other side. We're using [an ATtiny1616](https://www.adafruit.com/product/5690) so we have enough RAM to buffer a 512-pixel long strand. Now, to be fair - it's not super fast because [we have to write each pixel over I2C](https://learn.adafruit.com/adafruit-seesaw-atsamd09-breakout/neopixel), but with an 800KHz or 1MHz I2C clock and as long as you're not writing the whole strip at once, it's not so bad!

![](https://cdn-learn.adafruit.com/assets/assets/000/121/505/medium800/adafruit_products_5766-02.jpg?1685968175)

We add a 5V charge-pump, so even on 3V boards, you'll get a clean 5V signal. The pre-soldered terminal blocks and Stemma QT plugs make this a no-solder solution for adding NeoPixels easily to any device with I2C. The default I2C address is **0x60** but you can cut the bottom solder traces to change it to **0x60** - **0x67** inclusive.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/506/medium800/adafruit_products_5766-06.jpg?1685968221)

 **Please note:** To power NeoPixels, you'll need about 10-30mA per pixel of clean 5V DC power, provided on the terminal blocks, or you can just wire the 5V directly to the pixels if there are separate red and black power wires. There's no way the Stemma QT port can provide that much current so you can't just wire the pixels without an external power supply!

# Adafruit NeoDriver - I2C to NeoPixel Driver

## Pinouts

![](https://cdn-learn.adafruit.com/assets/assets/000/121/509/medium800/adafruit_products_double.jpg?1685972707)

The default I2C address is **0x60**.

## Power Pins

- **VIN** - This is the power pin for the ATtiny1616. To power the board, give it the same power as the logic level of your microcontroller - e.g. for a 3V microcontroller like a Feather RP2040 or most Single Board Computers, use 3V, or for a 5V microcontroller like Arduino, use 5V.
- **5Vin** - This is the NeoPixel power input, available thru the pin ( **5V** ) or terminal block ( **5Vin** ) on the left side of the board. To power NeoPixels, you'll need to provide 10-30mA per pixel of clean 5V DC power on this pin.
- **5Vo** - This is the NeoPixel power output, available thru the pin ( **5V** ) or terminal block ( **5Vo** ) on the right side of the board. The power provided on **5Vin** is output to this pin for the connected NeoPixels.
- **GND/G** - This is common ground for power and logic.

## I2C Logic Pins

The default I2C address is **0x60**.

- **SCL** - I2C clock pin, connect to your microcontroller I2C clock line. There's a **10K pullup** on this pin.
- **SDA** - I2C data pin, connect to your microcontroller I2C data line. There's a **10K pullup** on this pin.
- [**STEMMA QT**](https://learn.adafruit.com/introducing-adafruit-stemma-qt) **-** These connectors allow you to connect to development boards with **STEMMA QT** / Qwiic connectors or to other things with [various associated accessories](https://www.adafruit.com/category/619).

## Address Jumpers

On the back of the board are **three address jumpers** , labeled **A0** , **A1** , and **A2** above the breakout pads along the bottom of the board. These jumpers allow you to chain up to 8 of these boards on the same pair of I2C clock and data pins. To do so, you cut the jumpers "open" by separating the two pads.

If you happen to need more than 8, it's possible to set the I2C address with a special address-change command that is saved to the onboard non-volatile EEPROM memory.

The default I2C address is **0x60**. The other address options can be calculated by "adding" the **A0/A1/A2**  to the base of **0x60**.

**A0** sets the lowest bit with a value of **1** , **A1** sets the next bit with a value of **2** and **A2** sets the next bit with a value of **4**. The final address is **0x60 + A2 + A1 + A0** which would be **0x67**.

- 
If only **A0** is cut, the address is **0x60****  + 1 = 0x61**
- 
If only **A1** is cut, the address is **0x60****  + 2 = 0x62**
- 
If only **A2** is cut, the address is **0x60****  + 4 = 0x64**

The table below shows all possible addresses, and whether the pin(s) should be low (closed) or high (open).

![](https://cdn-learn.adafruit.com/assets/assets/000/121/510/medium800/adafruit_products_addr.png?1685973658)

## NeoPixel Data Pin

- **NEO** - The NeoPixel data output pin connects to the data input pin on your NeoPixel strip. This pin is can be accessed along the bottom of the board ( **NEO** ), the center of the board below the terminal block ( **NEO** ) and via the terminal block ( **Sig.** ). It is connected to pin **15** in the seesaw firmware.

## UPDI Pin

- **UPDI** - This is the single-pin **U** nified **P** rogram and **D** ebug **I** nterface. This pin is for external programming or on-chip-debugging for the ATtiny1616 running the [seesaw firmware](https://github.com/adafruit/Adafruit_seesawPeripheral). We have a [page in the ATtiny Breakouts with seesaw Learn Guide](https://learn.adafruit.com/adafruit-attiny817-seesaw/advanced-reprogramming-with-updi) detailing how to reprogram these chips with your own firmware (at your own risk). We don't provide any support for custom builds of seesaw - we think this is cool and useful for the Maker community.

## NeoPixel Activity LED

- NeoPixel Activity LED - On the front of the board, in the center to the right of the ATtiny1616, is the NeoPixel activity LED. It is a red LED. Whenever NeoPixel data is written out to the strip, it will light up. This is useful for debugging your setup

## Power LED

- **Power LED - ** On the front of the board, above the STEMMA connector on the left, is the power LED, labeled ** on**. It is the green LED.

# Adafruit NeoDriver - I2C to NeoPixel Driver

## CircuitPython and Python

It's easy to use the **NeoDriver** with Python or CircuitPython, and the [Adafruit\_CircuitPython\_seesaw](https://github.com/adafruit/Adafruit_CircuitPython_seesaw) module. This module allows you to easily write Python code that controls NeoPixels over I2C.

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

## CircuitPython Microcontroller Wiring

First wire up a NeoDriver to your board exactly as follows. The following is the NeoDriver wired to a Feather RP2040 using the STEMMA connector:

- **Board STEMMA 3V** to **driver VIN (red wire)**
- **Board STEMMA GND** to **driver****  GND (black wire)**
- **Board STEMMA SCL** to **driver****  SCL (yellow wire)**
- **Board STEMMA SDA** to **driver****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_featherSTEMMA_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/542/medium640/adafruit_products_featherSTEMMA_bb.jpg?1685987692)

The following is the NeoDriver wired to a Feather RP2040 using a solderless breadboard:

- **Board 3V** to **driver****  VIN (red wire)**
- **Board GND** to **driver****  GND (black wire)**
- **Board SCL** to **driver****  SCL (yellow wire)**
- **Board SDA** to **driver****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_featherBB_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/543/medium640/adafruit_products_featherBB_bb.jpg?1685987764)

## Python Computer Wiring

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).

Here's the Raspberry Pi wired with I2C using the STEMMA connector:

- **Pi 3V** to **adapter****  VIN (red wire)**
- **Pi GND** to **adapter****  GND (black wire)**
- **Pi SCL** to **adapter****  SCL (yellow wire)**
- **Pi SDA** to **adapter****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_piSTEMMA_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/544/medium640/adafruit_products_piSTEMMA_bb.jpg?1685987820)

Here's the Raspberry Pi wired with I2C using a solderless breadboard:

- **Pi 3V** to **adapter****  VIN (red wire)**
- **Pi GND** to **adapter****  GND (black wire)**
- **Pi SCL** to **adapter****  SCL (yellow wire)**
- **Pi SDA** to **adapter****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_piBB_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/545/medium640/adafruit_products_piBB_bb.jpg?1686013720)

## Python Installation of seesaw Library

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)!

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

- `pip3 install adafruit-circuitpython-seesaw`

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!

## CircuitPython Usage

To use with CircuitPython, you need to first install the **Adafruit\_CircuitPython\_seesaw** library, and its dependencies, into the **lib** folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script.

Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, and copy the **entire**  **lib**  **folder** and the **code.py** file to your **CIRCUITPY** drive.

Your **CIRCUITPY/lib** folder should contain the following folders and file:

- **adafruit\_bus\_device/**
- **adafruit\_seesaw/**
- **adafruit\_pixelbuf.mpy**

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

## Python Usage
Warning: This SeeSaw board prefers an i2c frequency of 400 kHz or higher. Most Pi's default to 100 kHz. You will need to update config.txt.

Modify the file **/boot/firmware/config.txt** by replacing the existing _i2c\_arm_ line with the following change. Reboot after updating the config.txt for the change to take effect. 

```terminal
dtparam=i2c_arm=on,i2c_arm_baudrate=400000
```

Once you have the library `pip3` installed on your computer, copy or download the following example to your computer, and run the following, replacing **code.py** with whatever you named the file:

`python3 code.py`

## Simple Test Example Code

**If running CircuitPython:** Once everything is saved to the **CIRCUITPY** drive, [connect to the serial console](https://learn.adafruit.com/welcome-to-circuitpython/kattni-connecting-to-the-serial-console) to see the data printed out!

**If running Python:** The console output will appear wherever you are running Python.

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

In the simple test example, the code instantiates the board over I2C and creates a `NeoPixel` object. In the loop, the connected NeoPixels advance through a rainbow color gradient.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/511/medium800/adafruit_products_5766-06.jpg?1685974959)

## Considerations for Other Single Board Computers

We often get folks asking how to get NeoPixels working on some OrangeBananaOnionRockchipAllWinner Pi type board and this breakout helps in solving that problem by sending the NeoPixel data over I2C.

All single board computers are different though and come with their own unique set of quirks. Here are some tips and tricks for trying out when using this breakout with your OrangeBananaOnionRockchipAllWinner Pi type board.

### Enable and Scan I2C

It may seem obvious, but making sure that the I2C bus is enabled properly on your board and is seeing the NeoDriver I2C address can vary from board to board. Some may have their own tool for doing this (similar to `raspi-config` on a Raspberry Pi), while others may expect you to do it via the terminal. You may need to enable a device tree overlay (`dtoverlay`) as well. Check your board manufacturer's wiki pages and support forums for the recommended technique. You can check which I2C buses are enabled on your board in the terminal:

`ls /dev/i2c*`

Once you have I2C enabled, you can connect the NeoDriver to the board's GPIO pins as described in the Raspberry Pi Fritzing diagrams earlier on this page and perform an I2C scan in the terminal:

`sudo i2cdetect -r -y BUSNUMBER` where `BUSNUMBER` is the expected I2C bus number (`0`, `1`, `2`, etc).

This will check to see if your board is recognizing the NeoDriver and to see which I2C bus it is connected to. If your board has a Raspberry Pi-compatible GPIO header, then I2C-1 will usually be located on pins **3** and **5** and I2C-0 will usually be located on pins **27** and **28**.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/564/medium800/adafruit_products_2023-06-04-115734_1920x1080_scrot_000.jpg?1686015180)

### Adafruit Extended Bus Library

The go-to way to instantiate I2C in Blinka is to use the **busio** module. However, if you find that your board's GPIO I2C buses are not being recognized with your Python code despite the device showing up in an I2C scan, you may want to switch to the [Adafruit\_Extended\_Bus](https://docs.circuitpython.org/projects/extended_bus/en/latest/) helper library.

The Extended Bus helper library allows the creation of I2C and SPI **busio** objects by passing in the Bus ID. This library is not compatible with CircuitPython and is intended to only be run on Linux devices. You can install it in the terminal with `pip`:

`pip3 install adafruit-extended-bus`

Here is example Python code for the NeoDriver using the Extended Bus library:

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

# Adafruit NeoDriver - I2C to NeoPixel Driver

## Python Docs

# Adafruit NeoDriver - I2C to NeoPixel Driver

## NeoDriver with Le Potato Single Board Computer

I had really good results using the NeoDriver with the [Le Potato single board computer](https://libre.computer/products/aml-s905x-cc/). Below are the steps that I found worked the best. Every single board computer is different, and configurations often change over time, so consider this page more of a suggested reference. Hopefully these steps give you clues for working with your flavor of OrangeBananaOnionRockchipAllWinner Pi.

JP also followed these steps when he put together his demo for his Product Pick of the Week live show.

https://www.youtube.com/watch?v=107IRg_XT7w

Warning: 

## Image the SD Card

There are a few different disk images available for the Le Potato, but I used the Raspbian image since that is familar to a lot of folks who have dabbled with a Raspberry Pi before. If your board has a Raspbian/Raspberry Pi OS image available try it out since it may be a little friendlier when interfacing with Blinka.

[Download the Raspbian image for sml-s905x](https://distro.libre.computer/ci/raspbian/11/) from the distro server. Use [etcher](https://etcher.balena.io/) to image the sd card.

## First Boot

The first boot is just like booting up Raspberry Pi OS on a Raspberry Pi. Follow the setup steps to create a local account, setup Wi-Fi and update the OS.

## Enable I2C

Enter `ls /dev/i2c-*` in the terminal to see the available I2C buses. Pins 3 and 5 are on bus AO and need to be enabled with a device tree overlay.

```
sudo ldto enable i2c-ao
ls -al /dev/i2c-*
```

Connect the NeoDriver to 3.3V, GND, SDA (pin 3) and SCL (pin 5) and perform an I2C scan.

```
sudo i2cdetect -y 2
```

You should see I2C address 0x60 appear in the scan. If you don't, try running `i2cdetect` on `0` or `1`.

Unfortunately it seems like the device tree overlays do not remain enabled upon rebooting so I've had to run the `ldto enable` command every time on boot. A bash script with the command could be created to have it execute on boot.

Warning: 

## Python and Blinka

Use the terminal to install these dependencies for Python and Blinka.

- `sudo apt install python3-pip`
- `sudo pip3 install --upgrade setuptools`
- `sudo apt-get install libgpiod2 python3-libgpiod`
- `pip3 install gpiod`
- `pip3 install adafruit-blinka`

Then run a test Python script to check that Blinka is running properly with GPIO and I2C.

```python
import board
import digitalio
import busio

print("Hello blinka!")

# Try to great a Digital input
pin = digitalio.DigitalInOut(board.P5)
print("Digital IO ok!")

# Try to create an I2C device
i2c = busio.I2C(board.SCL, board.SDA)
print("I2C ok!")

print("done!")
```

If it runs successfully then that means Blinka is all set. Next are the libraries for using the NeoDriver.

- `pip3 install adafruit-circuitpython-seesaw`
- `pip3 install adafruit-extended-bus`

The default busio I2C bus for Blinka doesn't seem to match-up with the GPIO I2C buses on Le Potato. Luckily there's the extended bus library that can let you pass the Linux bus ID.

## NeoDriver Test

After the seesaw and extended bus libraries are installed, you can try running a NeoPixel test. Connect the NeoPixels to the NeoPixel output terminal block pins and connect a 5V power supply to the power input terminal block pins. 

Then run this test code! It should be a rainbow swirl.

```python
import time
from rainbowio import colorwheel
from adafruit_extended_bus import ExtendedI2C as I2C
from adafruit_seesaw import seesaw, neopixel

i2c = I2C(1, frequency = 800000)
ss = seesaw.Seesaw(i2c, addr=0x60)
neo_pin = 15
num_pixels = 30

pixels = neopixel.NeoPixel(ss, neo_pin, num_pixels, brightness = 0.3, auto_write=False)

color_offset = 0

while True:
    for i in range(num_pixels):
        rc_index = (i * 256 // num_pixels) + color_offset
        pixels[i] = colorwheel(rc_index & 255)
    pixels.show()
    color_offset += 8
    time.sleep(0.01)
```

# Adafruit NeoDriver - I2C to NeoPixel Driver

## Arduino

Using the NeoDriver with Arduino involves wiring up the driver to your Arduino-compatible microcontroller, installing the [Adafruit\_Seesaw](https://github.com/adafruit/Adafruit_Seesaw) library and running the provided example code.

## Wiring

Wire as shown for a **5V** board like an Uno. If you are using a **3V** board, like an Adafruit Feather, wire the board's 3V pin to the adapter VIN.

Here is an Adafruit Metro wired up to the driver using the STEMMA QT connector:

- **Board 5V** to **driver VIN (red wire)**
- **Board GND** to **driver****  GND (black wire)**
- **Board SCL** to **driver****  SCL (yellow wire)**
- **Board SDA** to **driver****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_metroSTEMMA_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/546/medium640/adafruit_products_metroSTEMMA_bb.jpg?1686013984)

Here is an Adafruit Metro wired up using a solderless breadboard:

- **Board 5V** to **driver****  VIN (red wire)**
- **Board GND** to **driver****  GND (black wire)**
- **Board SCL** to **driver****  SCL (yellow wire)**
- **Board SDA** to **driver****  SDA (blue wire)**
- **5V power supply positive** to **driver 5Vin (red wire)**
- **5V power supply ground** to **driver G (black wire)**
- **NeoPixel power** to **driver 5Vo (red wire)**
- **NeoPixel data** to **driver Neo (green wire)**
- **NeoPixel ground** to **driver G (black wire)**

![adafruit_products_metroBB_bb.jpg](https://cdn-learn.adafruit.com/assets/assets/000/121/547/medium640/adafruit_products_metroBB_bb.jpg?1686013993)

## Library Installation

You can install the **Adafruit\_Seesaw** library for Arduino using the Library Manager in the Arduino IDE.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/512/medium800/adafruit_products_Arduino_Open_Library_Manager.png?1685976683)

Click the **Manage Libraries ...** menu item, search for **Adafruit\_Seesaw** , and select the **Adafruit seesaw Library** library:

![](https://cdn-learn.adafruit.com/assets/assets/000/121/513/medium800/adafruit_products_seesawLib.png?1685976729)

If asked about dependencies, click "Install all".

![](https://cdn-learn.adafruit.com/assets/assets/000/121/514/medium800/adafruit_products_seesawDepends.png?1685976745)

If the "Dependencies" window does not come up, then you already have the dependencies installed.

Warning: 

## Example Code
https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/NeoDriver_seesaw_Examples/Arduino_NeoDriver_strandtest/Arduino_NeoDriver_strandtest.ino

![](https://cdn-learn.adafruit.com/assets/assets/000/121/548/medium800/adafruit_products_ardSerial.png?1686013926)

Upload the sketch to your board and open up the Serial Monitor ( **Tools -\> Serial Monitor** ) at 115200 baud. You'll see the seesaw I2C address ( **0x60** ) recognized by the code. Then, you'll see the attached NeoPixels advance through a rainbow color gradient.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/515/medium800/adafruit_products_5766-06.jpg?1685976846)

# Adafruit NeoDriver - I2C to NeoPixel Driver

## Arduino Docs

# Adafruit NeoDriver - I2C to NeoPixel Driver

## Downloads

## Files

- [ATtiny1616 Datasheet](https://cdn-learn.adafruit.com/assets/assets/000/118/839/original/ATtiny1616-Datasheet.pdf?1677164088)
- [EagleCAD PCB files on GitHub](https://github.com/adafruit/Adafruit-NeoDriver-STEMMA-QT-PCB)
- [3D Models on GitHub](https://github.com/adafruit/Adafruit_CAD_Parts/tree/main/5766%20NeoDriver%20STEMMA%20QT)
- [Fritzing object in the Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library/blob/master/parts/Adafruit%20NeoDriver%20STEMMA%20QT.fzpz)

## Schematic and Fab Print

Dimensions in inches.

![](https://cdn-learn.adafruit.com/assets/assets/000/121/507/medium800/adafruit_products_schem.png?1685970802)

![](https://cdn-learn.adafruit.com/assets/assets/000/121/508/medium800/adafruit_products_fab.png?1685970810 dimensions in inches)

## 3D Model
![](https://cdn-learn.adafruit.com/assets/assets/000/126/783/medium800/adafruit_products_5766_NeoDriver_STEMMA_QT.jpg?1703085790)


## Primary Products

### Adafruit NeoDriver - I2C to NeoPixel Driver Board - Stemma QT

[Adafruit NeoDriver - I2C to NeoPixel Driver Board - Stemma QT](https://www.adafruit.com/product/5766)
NeoPixel LEDs (a.k.a WS2812 / SK6812 family) are a super-easy way to add addressable RGB lighting with only one GPIO. They're ubiquitous on microcontrollers, but some chips or single board computers (SBCs) don't have neopixel support due to the precision timing required to send...

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

## Featured Products

### STEMMA QT / Qwiic JST SH 4-Pin Cable - 50mm Long

[STEMMA QT / Qwiic JST SH 4-Pin Cable - 50mm Long](https://www.adafruit.com/product/4399)
This 4-wire cable is 50mm / 1.9" long and fitted with JST SH female 4-pin connectors on both ends. Compared with the chunkier JST PH these are 1mm pitch instead of 2mm, but still have a nice latching feel, while being easy to insert and remove.

<a...></a...>

In Stock
[Buy Now](https://www.adafruit.com/product/4399)
[Related Guides to the Product](https://learn.adafruit.com/products/4399/guides)
### STEMMA QT / Qwiic JST SH 4-pin Cable with Premium Female Sockets

[STEMMA QT / Qwiic JST SH 4-pin Cable with Premium Female Sockets](https://www.adafruit.com/product/4397)
This 4-wire cable is a little over 150mm / 6" long and fitted with JST-SH female 4-pin connectors on one end and premium female headers on the other. Compared with the chunkier JST-PH these are 1mm pitch instead of 2mm, but still have a nice latching feel, while being easy to insert and...

In Stock
[Buy Now](https://www.adafruit.com/product/4397)
[Related Guides to the Product](https://learn.adafruit.com/products/4397/guides)
### STEMMA QT / Qwiic JST SH 4-pin to Premium Male Headers Cable

[STEMMA QT / Qwiic JST SH 4-pin to Premium Male Headers Cable](https://www.adafruit.com/product/4209)
This 4-wire cable is a little over 150mm / 6" long and fitted with JST-SH female 4-pin connectors on one end and premium Dupont male headers on the other. Compared with the chunkier JST-PH these are 1mm pitch instead of 2mm, but still have a nice latching feel, while being easy to insert...

In Stock
[Buy Now](https://www.adafruit.com/product/4209)
[Related Guides to the Product](https://learn.adafruit.com/products/4209/guides)
### Adafruit NeoPixel Digital RGB LED Strip - Black 60 LED 1m

[Adafruit NeoPixel Digital RGB LED Strip - Black 60 LED 1m](https://www.adafruit.com/product/2508)
You thought it couldn't get better than [our world-famous 32-LED-per-meter Digital LED strip](http://adafruit.com/products/306) but we will prove you wrong! You wanted **twice the LEDs**? We got it (well, it's 1.875 times as many but that's within a margin of error)....

In Stock
[Buy Now](https://www.adafruit.com/product/2508)
[Related Guides to the Product](https://learn.adafruit.com/products/2508/guides)
### 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)
### 5V 2A (2000mA) switching power supply - UL Listed

[5V 2A (2000mA) switching power supply - UL Listed](https://www.adafruit.com/product/276)
This is an FCC/CE certified and UL listed power supply. Need a lot of 5V power? This switching supply gives a clean regulated 5V output at up to 2000mA. 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...

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

## Related Guides

- [Adafruit Pixel Trinkey](https://learn.adafruit.com/adafruit-pixel-trinkey.md)
- [PyPortal Voice Controlled Smart Switch and Time Display](https://learn.adafruit.com/pyportal-voice-controlled-smart-switch-and-time-display.md)
- [Hacking Holiday Animatronics](https://learn.adafruit.com/hacking-holiday-animatronics.md)
- [Deciphering Strange Arduino Code](https://learn.adafruit.com/deciphering-strange-arduino-code.md)
- [Adafruit TDK InvenSense ICM-20948 9-DoF IMU](https://learn.adafruit.com/adafruit-tdk-invensense-icm-20948-9-dof-imu.md)
- [Tombstone Prop-Maker RP2040](https://learn.adafruit.com/tombstone-prop-maker-rp2040.md)
- [Introduction to the Mastodon API using CircuitPython](https://learn.adafruit.com/intro-to-mastodon-api-circuitpython.md)
- [Windows IoT Core Application Development: Headed Blinky](https://learn.adafruit.com/windows-iot-application-development-headed-blinky.md)
- [Bluetooth Remote Control for the Lego Droid Developer Kit](https://learn.adafruit.com/bluetooth-remote-for-lego-droid.md)
- [Adafruit QT Py CH32V203](https://learn.adafruit.com/adafruit-qt-py-ch32v203.md)
- [Adafruit Feather RP2040 with DVI Output Port](https://learn.adafruit.com/adafruit-feather-rp2040-dvi.md)
- [Windows IoT Core Application Management](https://learn.adafruit.com/windows-iot-application-management.md)
- [Stand-alone programming AVRs using CircuitPython](https://learn.adafruit.com/stand-alone-programming-avrs-using-circuitpython.md)
- [Adafruit DotStar FeatherWing](https://learn.adafruit.com/adafruit-dotstar-featherwing-adafruit.md)
- [Raspberry Pi I2C Clock Stretching Fixes](https://learn.adafruit.com/raspberry-pi-i2c-clock-stretching-fixes.md)