# RGB LED Matrix Basics

## Overview

This guide is for boards in the **ARDUINO ecosystem**. We have a [different guide for Raspberry Pi](https://learn.adafruit.com/adafruit-rgb-matrix-plus-real-time-clock-hat-for-raspberry-pi), and another for [CircuitPython](https://learn.adafruit.com/rgb-led-matrices-matrix-panels-with-circuitpython).

Arduino Uno is limited to 32x16 pixels, single-buffered.

Info: 

![](https://cdn-learn.adafruit.com/assets/assets/000/002/935/medium800/led_matrix_rgbmatrix.jpg?1396789179)

Bring a little bit of Times Square into your home with our RGB LED matrix panels. These panels are normally used to make video walls — here in New York we see them on the sides of buses and on bus stops — to display animations or short video clips. We thought they looked really cool so we picked up a few boxes from the factory. One has 512 bright RGB LEDs arranged in a 16x32 grid on the front, the other has 1024 LEDs in a 32x32 grid. On the back is a PCB with IDC connectors (one set for input, one for output: in theory you can chain these together) and 12 16-bit latches that allow you to drive the display with a 1:8 (16x32) or 1:16 (32x32) scan rate.

# **COMPATIBLE HARDWARE**

The following boards are **plug-and-play ready** with the RGB Matrix Shield and software mentioned in this guide:

- **Adafruit Metro M0**
- **Arduino Zero**
- **Arduino Uno**  (or compatible ATmega328P boards) — **limited to 32x16 matrix** , no double-buffering (needed for flicker-free animation)

The following are supported by the software, but require **additional wiring or jumpers** to use the RGB Matrix Shield:

- **Arduino Mega** (or compatible ATmega2560 boards)
- **Adafruit Metro M4**
- **Adafruit Metro RP2350** (requires address pins {A, B, C, D} get jumper wires)

The following are **NOT supported** by the software or shield:

- **Arduino Leonardo** (or compatible ATmega32U4 boards) (though the same form factor, the Uno and Leonardo route different shield connections to the microcontroller)
- **Netduino** and other Arduino-alikes not mentioned in above lists (but other libraries or shields might exist elsewhere)
- **Teensy** (but see the **SmartLED** Shields and software for Teensy 3.X and 4.X, which provide excellent performance)
- **Raspberry Pi** (but there are different [Bonnets](https://learn.adafruit.com/adafruit-rgb-matrix-bonnet-for-raspberry-pi) and [HATs](https://learn.adafruit.com/adafruit-rgb-matrix-plus-real-time-clock-hat-for-raspberry-pi) for this)

# **COMPATIBLE SOFTWARE**

The software support for driving the RGB matrix panels has evolved with time and the availability of newer, more powerful Arduino boards. **There are currently two different Arduino libraries.** Which library to use depends on the Arduino board being used.

- [RGB matrix Panel](https://github.com/adafruit/RGB-matrix-Panel) - This is the older, original library and is covered later in this guide. Use this library with an **Arduino UNO** or **Arduino Mega**.
- [Adafruit Protomatter](https://github.com/adafruit/Adafruit_Protomatter) - This is a newer library covered in a [separate guide](https://learn.adafruit.com/adafruit-protomatter-rgb-matrix-library/overview). Use this library with an **Arduino Zero** , **Metro M0** , **Metro M4** , **RP2040** based board, **ESP32** based board, or other supported **32bit boards**. [See the Protomatter guide for more details.](https://learn.adafruit.com/adafruit-protomatter-rgb-matrix-library/overview)

![](https://cdn-learn.adafruit.com/assets/assets/000/002/936/medium800/led_matrix_rgbmatrix3232_lrg.jpg?1396789186)

These panels require 12 or 13 digital pins (6 bit data, 6 or 7 bit control) and a good 5V power supply, at least a couple amps per panel. We suggest our 2A (or larger) regulated 5V adapters and either a terminal block DC jack, or solder a jack from our DC extension cord. Please read the rest of our tutorial for more details!  
  
Keep in mind that these displays are normally designed to be driven by FPGAs or other high speed processors; they do not have built in PWM control of any kind. Instead, you're supposed to redraw the screen over and over to 'manually' PWM the whole thing. On a 16 MHz Arduino, we managed to squeeze 12-bit color (4096 colors) but this display would really shine if driven by an FPGA, CPLD, Propeller, XMOS or other high speed multi-processor controller.

![](https://cdn-learn.adafruit.com/assets/assets/000/002/937/medium800/led_matrix_plasma.jpg?1396789196)

Of course, we wouldn't leave you with a datasheet and a "good luck!" We have a full wiring diagrams and working Arduino library code with examples from drawing pixels, lines, rectangles, circles and text. You'll get your color blasting within the hour! On most Arduino-compatible boards, you'll need 12 digital pins, and about 800 bytes of RAM to hold the 12-bit color image (double that for the 32x32 matrix, double again for smooth double-buffered animation).

Danger: 

# RGB LED Matrix Basics

## Power

Although LEDs are very efficient light sources, get enough of them in one place and the current really adds up.

A _single_ **32x16** or **32x32** RGB matrix, running full tilt (all pixels set white), can require nearly _ **4 Amps** _ of current! Double that figure for a **64x32** matrix.

On _average_ though, displaying typical graphics and animation, these panels will use less…a **2A** supply is usually sufficient for a single 32x16 or 32x32 panel, or 4A for a 64x32 panel. There’s no harm in using a larger power supply rated for more _Amps_ (e.g. a 10A supply), but _never_ use one with a higher _Voltage_ (use  **5V, period** )!

On these panels, the power connection is separate from the data connection. Let’s begin by connecting a 5V supply…

Our parts suppliers occasionally make revisions to designs. As a result, the connections have changed over time. We'll walk through the different wiring combinations here…pick the explanation that matches the panel(s) you received.  
  
Two different types of power connectors have made an appearance:

![](https://cdn-learn.adafruit.com/assets/assets/000/002/938/medium800/led_matrix_connectors-compared.jpg?1396789202)

On the left is a screw post power connector (with adjacent pads for soldering wires directly). On the right, a Molex-style header. Some panels will have _two_ headers…the power cable included with these panels has connectors for both headers.  
  
With the posts-and-pads connector, you can either screw down the spades from the power cable, or another approach is to [cut a 2.1mm jack from this extension cord](https://www.adafruit.com/products/327) and solder it to the pads on the panel back. [This way you can plug the 5V from a wall adapter](https://www.adafruit.com/products/276) right in (the one we have in the shop is suggested). Simply cut the other half of the cable off, and strip the wiring so you can solder the red wire to +5 and the black wire to ground.

![](https://cdn-learn.adafruit.com/assets/assets/000/002/939/medium800/led_matrix_dcplugcut.jpg?1396789211)

Solder both pins correctly to the power port. Make sure you get this right because there is no protection diode!![](https://cdn-learn.adafruit.com/assets/assets/000/002/940/medium800/led_matrix_5vsoldered.jpg?1396789215)

If your panel has the Molex-style header, just plug in the included power cable, observing the correct polarity.![](https://cdn-learn.adafruit.com/assets/assets/000/002/941/medium800/led_matrix_power-cable.jpg?1396789224)

If your power cable came with spades at the opposite end of this power cable, they can be screwed into a 2.1mm terminal block adapter. Works nicely! Don't allow the exposed connectors to contact metal though…you should probably cover this with heat-shrink tube or electrical tape.

![](https://cdn-learn.adafruit.com/assets/assets/000/002/942/medium800/led_matrix_3232jack.jpg?1396789232)

Warning: 

![](https://cdn-learn.adafruit.com/assets/assets/000/032/612/medium800/led_matrix_round.jpg?1464024147)

# RGB LED Matrix Basics

## Connections

These panels are normally designed for _chaining_ (linking end-to-end into larger displays)…the output of one panel connects to the input of the next, down the line.

With the limited RAM in an Arduino, chaining is seldom practical. Still, **it’s necessary to distinguish the input and output connections** on the panel…it won’t respond if we’re connected to the wrong socket.

Danger: Although the panels support chaining, this is VERY impractical on Arduino-class boards and our library DOES NOT SUPPORT it. A more powerful system like a Raspberry Pi may be a better choice for chained panels!

Flip the matrix over so you’re looking at the back, holding it with the two sockets situated at the **left and right edges** (not top and bottom).

On some panels, if you’re lucky, the sockets are labeled INPUT and OUTPUT (sometimes IN and OUT or similar), so it’s obvious which is the input socket.  
   
If INPUT is not labeled, look for one or more arrows pointing in the **horizontal**  direction (ignore any vertical arrows, whether up or down). The horizontal arrows show the direction data moves from INPUT to OUTPUT — then you know which connector is which.  
   
If no such labels are present, a last option is to examine the plastic shroud around the connector pins. The key (notch) on the INPUT connector will face the outer edge of the panel (not the center).

![](https://cdn-learn.adafruit.com/assets/assets/000/023/772/medium800/led_matrix_orient.png?1426306203)

 **The arrangement of pins on the INPUT connector varies with matrix size and the batch in which it was produced…**

A **32x16** panel uses this pin arrangement. The labels might be slightly different, or the pins might not be labeled at all…but in either case, use this image for reference.

 

Notice there are four ground connections. To ensure reliable performance, **_all four_ should be connected to GND** on the Arduino! A solderless breadboard is handy for making this split.

![led_matrix_socket1.png](https://cdn-learn.adafruit.com/assets/assets/000/023/767/medium640/led_matrix_socket1.png?1426305716)

Here’s the layout for **32x32** and **64x32** panels. We’ll call this “ **Variant A**.” Some panels use different labels, but the functions are identical.

 

The layout is very similar to the 32x16 panel, with pin “D” replacing one ground connection.

 

**This is the layout we’ll be referencing most often.**

 

**If you have a 32x32 panel with _no pin labels at all,_ then use this layout.**

![led_matrix_socket2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/768/medium640/led_matrix_socket2.png?1426305708)

Info: On the 64x32 2.5mm panels (product ID [5036](https://www.adafruit.com/product/5036)), the green and blue channels are swapped compared to the standard HUB75 pinout. When using with libraries, simply swap the pin numbers for G1, G2 with B1, B2 in software to flip them back around.

If you are using the CircuitPython `MatrixPortal` library, you do not need to swap pins explicitly. Instead, add this argument to the constructor: `MatrixPortal(..., color_order="RBG", ...)`. The default order is `"RGB"`, and this argument will swap the pins to match the specified `"RBG"` order.

“ **Variant B** ” for **32x32** and **64x32** panels.  **The wiring is _identical_ to Variant A above, _only the labels_ are different.**

 

Ground pins aren’t labeled, but still need to be connected.

 

LAT (latch) is labeled STB (strobe) here. R1/G1/B1/R2/G2/B2 are changed to R0/G0/B0/R1/G1/B1…but again, no functional difference, it’s just ink.

![led_matrix_socket3.png](https://cdn-learn.adafruit.com/assets/assets/000/023/769/medium640/led_matrix_socket3.png?1426305755)

Our earliest **32x32** panels had a **two-socket**  design, let’s call it “ **Variant C**.” All the same pin functions are present but the layout is very different.

 

R/G/B on the **upper**  socket correspond to R1/G1/B1 in Variant A. R/G/B on the **lower**  socket correspond to R2/G2/B2.

 

All the other signals (A/B/C/D/CLK/LAT/OE) need to be connected to **both** sockets — e.g. one pin on the Arduino drives both CLK pins, and so forth.

![led_matrix_socket4.png](https://cdn-learn.adafruit.com/assets/assets/000/023/770/medium640/led_matrix_socket4.png?1426305854)

# Connecting to Arduino

There are two or three methods for connecting a matrix to an Arduino:

1. **Jumper wires** inserted between Arduino headers and a ribbon cable — this works well for testing and prototyping, but is not durable.
2. The **Adafruit RGB Matrix Shield** makes connecting these panels to an Arduino as easy as can be, and is best for permanent installations.
3. One could build a **_proto shield_**  to replicate the pinout of option #2. But given the Matrix Shield’s low cost, this might not be worth the effort nowadays.

These panels are normally run by very fast processors or FPGAs, not a 16 MHz Arduino. To achieve reasonable performance in this limited environment, our software is optimized by  **tying specific signals to specific Arduino pins**. A _few_ control lines can be reconfigured, but others are very specific… **you can’t wire the whole thing willy-nilly.** The next pages demonstrate compatible wiring…one using the RGB Matrix Shield, the using jumper wires.

# RGB LED Matrix Basics

## Connecting Using RGB Matrix Shield

This is the **preferred** method for pairing these matrices with an Arduino-sized board, as it’s quick and trouble-free.

The **Adafruit RGB Matrix Shield** works with the **Arduino Uno** and **Zero** , and the **Adafruit Metro M0** …and with one or more jumper wires can work with the **Metro M4** (and potentially other boards with this form factor, if a compatible Arduino library is available).

The shield does **_not_**  directly work with the Arduino Mega — additional jumper wires are needed to pins off the shield — see the “Jumper Wires” page for pinouts, or consider making your own Mega proto shield for that board.

## Assembling the Partially Assembled Version
The shield comes with the button, terminal block, and the 16-pin header already soldered on. All you need to do is solder the headers!

The included headers should be installed from the underside and soldered from the top.

![led_matrices_RGBMS_top_header.jpg](https://cdn-learn.adafruit.com/assets/assets/000/120/965/medium640/led_matrices_RGBMS_top_header.jpg?1683909012)

![led_matrices_RGBMS_top_angle.jpg](https://cdn-learn.adafruit.com/assets/assets/000/120/966/medium640/led_matrices_RGBMS_top_angle.jpg?1683909028)

## Assembling the Original Version
The shield arrives unpopulated and you’ll need to do a little soldering to get it going.

Header pins are installed from the underside and soldered on top. Three components — a button, power terminal and 16-pin header — insert from the top and are soldered underneath.

**The 16-pin (8x2) header must be installed in the correct orientation!** The polarity notch is indicated on the silkscreen, or you can see in the photos above that the notch faces the digital I/O pins. If you install this backwards the matrix will not work!

![led_matrices_umpopulated.jpg](https://cdn-learn.adafruit.com/assets/assets/000/055/701/medium640/led_matrices_umpopulated.jpg?1529447599)

![led_matrices_populated.jpg](https://cdn-learn.adafruit.com/assets/assets/000/055/702/medium640/led_matrices_populated.jpg?1529447609)

## Powering the Shield

Power to the LED matrix can be connected to the shield’s screw terminals — red wire to +5Vout, black wire to GND — and the whole circuit is then powered from the Arduino’s DC jack or a USB cable at a safe and regulated 5 Volts.

## Metro M4 Usage
The shield requires a small modification to work with the Adafruit **Metro M4** :

- Use a small file or hobby knife to cut the PCB trace between the two pads indicated here.
- Solder a wire from the adjacent “CLK” pin to the “Analog In 4” pin.

![led_matrices_metro-m4-diagram.jpg](https://cdn-learn.adafruit.com/assets/assets/000/055/703/medium640/led_matrices_metro-m4-diagram.jpg?1529450576)

A corresponding change is required in one’s code — look for the “CLK” pin definition in any of the matrix examples…

```
#define CLK 8
```

And change the “8” to “A4”:

```
#define CLK A4
```

Warning: 

## Metro RP2350 Usage
Jumper Wires are needed for the four address pins A, B, C and D. The reason for this is those address pins on the shield align to the RP2350 Port 1. However all GPIOs need to be on Port 0 for this chip to work. This means each on the shield pins A0, A1, A2 and A3 need to have a trace cut and a small wire soldered re-routing the connections over to the D1, D11, D22 and D23 pins of the Metro RP2350. 

```auto
Address Line   Shield Default   (Port 1, bad)   →   Rewired To    (Port 0, good)
-----------------------------------------------------------------------------
A              A0  (GPIO42)                     →   D1   (GPIO1, TX)
B              A1  (GPIO43)                     →   D11  (GPIO11)
C              A2  (GPIO44)                     →   D22  (GPIO22)
D              A3  (GPIO45)                     →   D23  (GPIO23)
```

![](https://cdn-learn.adafruit.com/assets/assets/000/139/738/medium800/led_matrices_IMG_3748.jpeg?1758134481 Metro RP2350 RGB Matrix Shield)

## Metro RP2350 CircuitPython Shapes
```auto
import board
import displayio
import rgbmatrix
import framebufferio
from adafruit_display_shapes.circle import Circle
from adafruit_display_shapes.rect import Rect
from adafruit_display_shapes.triangle import Triangle

displayio.release_displays()

# Panel wiring with A→D1, B→D11, C→D22, D→D23
matrix = rgbmatrix.RGBMatrix(
    width=64, height=32, bit_depth=4,
    rgb_pins=[board.D2, board.D3, board.D4, board.D5, board.D6, board.D7],
    addr_pins=[board.D1, board.D11, board.D22, board.D23],  # rewired
    clock_pin=board.D8,
    latch_pin=board.D10,
    output_enable_pin=board.D9,
    doublebuffer=True
)
display = framebufferio.FramebufferDisplay(matrix, auto_refresh=True)

# Root group
root = displayio.Group()
display.root_group = root

# Background (black rectangle)
root.append(Rect(0, 0, display.width, display.height, fill=0x000000))

# Shapes
root.append(Circle(12, 16, 10, fill=0xFF0000))        # red circle left
root.append(Rect(26, 8, 14, 14, fill=0x00FF00))       # green square center
root.append(Triangle(42, 24, 50, 8, 58, 24, fill=0x0000FF))  # blue triangle right

# Done — shapes are static, nothing else needed
while True:
    pass
```

# RGB LED Matrix Basics

## Connecting with Jumper Wires

Danger: 

Ribbon cables and their corresponding headers are sometimes a topological puzzle. Here’s a trick to help keep track…

If you hold the ribbon cable flat — no folds — and with both connectors facing you, keys pointed the same direction — now there is a 1:1 correlation between the pins. The top-right pin on one plug links to the top-right on the other plug, and so forth. This holds true even if the cable has a doubled-over strain relief. **As long as the keys point the same way and the plugs face the same way, pins are in the same positions at both ends.**

![](https://cdn-learn.adafruit.com/assets/assets/000/023/920/medium800/led_matrix_cable1.png?1426541458)

Plugged into a socket on the LED matrix, one header now faces _away_ from you. If you double the cable back on itself (not a twist, but a fold)…to access a specific pin on the socket, the left and right columns are now mirrored (rows are in the same order — the red stripe provides a point of reference). You’re looking “up” into the plug rather than “down” into the socket.

For example, R1 (the top-left pin on the INPUT socket) appears at the top-_right_ of the exposed plug. You can jam a wire jumper in that hole to a corresponding pin on the Arduino…

![](https://cdn-learn.adafruit.com/assets/assets/000/023/921/medium800/led_matrix_cable2.png?1426541485)

So! From the prior page, refer to the socket that’s correct for your matrix type. The labels may be a little different (or none at all), but most are pretty close to what’s shown here.

 

Then _swap the columns_ to find the correct position for a given signal.

![led_matrix_socket2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/825/medium640/led_matrix_socket2.png?1426392340)

![led_matrix_plug2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/826/medium640/led_matrix_plug2.png?1426392350)

 **Either end of the ribbon cable can be plugged into the matrix INPUT socket.** Notice below, the “key” faces the same way regardless.

With the free end of the ribbon toward the center of the matrix, the Arduino can be hidden behind it.

With the free end of the ribbon off the side, it’s easier to see both the front of the matrix and the Arduino simultaneously, for making additional connections or for troubleshooting.

![](https://cdn-learn.adafruit.com/assets/assets/000/023/929/medium800/led_matrix_ribbon-2ways-jumper.png?1426548655)

Using color-coded wires helps a _lot!_ If you don’t have colored wires, that’s okay, just pay close attention where everything goes. Our goal is a fully-populated plug like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/023/922/medium800/led_matrix_jumpers.jpg?1426541597)

So! Let’s proceed with the wiring, in groups…

# Connect Ground Wires
 **32x32** and **64x32** matrices require **three** ground connections. **32x16** matrices have **four**.

 

Current **Arduino Uno form-factor**  boards have **three** ground pins (the third is next to pin 13). If you need additional ground connections — for a 32x16 matrix, or if using an older Arduino board with only 2 ground pins — a solderless breadboard is handy for linking all these pins.

 

**Arduino Mega** boards have **five** ground pins. Same three as the Arduino Uno, plus two more next to pins 52 & 53.

![led_matrix_breadboard.jpg](https://cdn-learn.adafruit.com/assets/assets/000/023/824/medium640/led_matrix_breadboard.jpg?1426392323)

![led_matrix_plug-gnds.png](https://cdn-learn.adafruit.com/assets/assets/000/023/844/medium640/led_matrix_plug-gnds.png?1426484021)

![led_matrix_uno-gnds.png](https://cdn-learn.adafruit.com/assets/assets/000/023/847/medium640/led_matrix_uno-gnds.png?1426485631)

![led_matrix_mega-gnds.png](https://cdn-learn.adafruit.com/assets/assets/000/023/848/medium640/led_matrix_mega-gnds.png?1426485637)

# Upper RGB Data
Pins **R1** , **G1** and **B1** (labeled R0, B0 and G0 on some matrices) deliver data to the **top half** of the display.

 

On the **Arduino Uno** and **Adafruit Metro (328, M0** or **M4) **boards, connect these to digital pins **2** , **3** and **4**.

 

On **Arduino Mega** , connect to pins **24** , **25** and **26**.

![led_matrix_plug-rgb1.png](https://cdn-learn.adafruit.com/assets/assets/000/023/857/medium640/led_matrix_plug-rgb1.png?1426486361)

![led_matrix_uno-rgb1.png](https://cdn-learn.adafruit.com/assets/assets/000/023/858/medium640/led_matrix_uno-rgb1.png?1426486371)

![led_matrix_mega-rgb1.png](https://cdn-learn.adafruit.com/assets/assets/000/023/859/medium640/led_matrix_mega-rgb1.png?1426486393)

# Lower RGB Data
Pins **R2** , **G2** and **B2** (labeled R1, G1 and B1 on some matrices) deliver data to the **bottom half** of the display. These connect to the next three Arduino pins…

 

On **Arduino Uno** and **Adafruit Metros** , that’s pins **5** , **6** and **7**.

 

On **Arduino Mega** , pins **27** , **28** and **29**.

![led_matrix_plug-rgb2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/846/medium640/led_matrix_plug-rgb2.png?1426484827)

![led_matrix_uno-rgb2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/851/medium640/led_matrix_uno-rgb2.png?1426485688)

![led_matrix_mega-rgb2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/852/medium640/led_matrix_mega-rgb2.png?1426485697)

# Row Select Lines
Pins **A** , **B** , **C** and **D** select which two rows of the display are currently lit. ( **32x16 matrices don’t have a “D” pin** — it’s connected to **ground** instead.)

 

These connect to pins **A0** , **A1** , **A2** and (if D pin present) **A3**. This is the **same**  for all boards.

![led_matrix_plug-rows.png](https://cdn-learn.adafruit.com/assets/assets/000/023/876/medium640/led_matrix_plug-rows.png?1426528173)

![led_matrix_uno-rows.png](https://cdn-learn.adafruit.com/assets/assets/000/023/912/medium640/led_matrix_uno-rows.png?1426539184)

# LAT Wire
The  **LAT**  signal connects to Arduino pin **10**.

This is the same for all boards.

The LAT (latch) signal marks the end of a row of data.

![led_matrix_plug-lat.png](https://cdn-learn.adafruit.com/assets/assets/000/023/913/medium640/led_matrix_plug-lat.png?1426540774)

![led_matrices_uno-lat-NEW.png](https://cdn-learn.adafruit.com/assets/assets/000/056/384/medium640/led_matrices_uno-lat-NEW.png?1530077713)

# OE Wire
 **OE** connects to Arduino pin **9**. This is the same for all boards.

OE (output enable) switches the LEDs off when transitioning from one row to the next.

![led_matrix_plug-oe.png](https://cdn-learn.adafruit.com/assets/assets/000/023/918/medium640/led_matrix_plug-oe.png?1426541287)

![led_matrices_uno-oe-new.png](https://cdn-learn.adafruit.com/assets/assets/000/056/385/medium640/led_matrices_uno-oe-new.png?1530077737)

# CLK Wire

Last one!

 **CLK** connects to…

- **Pin 8** on **Arduino Uno** , **Adafruit Metro 328** or **Metro M0**.
- **Pin 11** on **Arduino Mega**.
- **Pin A4** on **Adafruit Metro M4** (not shown, but you get the idea).

The CLK (clock) signal marks the arrival of each bit of data.

![led_matrix_plug-clk.png](https://cdn-learn.adafruit.com/assets/assets/000/023/915/medium640/led_matrix_plug-clk.png?1426541145)

![led_matrices_uno-clk-new.png](https://cdn-learn.adafruit.com/assets/assets/000/056/386/medium640/led_matrices_uno-clk-new.png?1530077773)

![led_matrices_mega-clk-new.png](https://cdn-learn.adafruit.com/assets/assets/000/056/387/medium640/led_matrices_mega-clk-new.png?1530077785)

That’s it. You can skip ahead to the “Test Example Code” page now.

# RGB LED Matrix Basics

## Connecting Using a Proto Shield

As mentioned on the “Jumper” page: if you hold a ribbon cable flat — no folds — and with both connectors facing you, keys pointed the same direction — there’s is a 1:1 correlation between the pins. The top-right pin on one plug links to the top-right on the other plug, and so forth. This holds true even if the cable has a doubled-over strain relief. **As long as the keys point the same way and the plugs face the same way, pins are in the same positions at both ends.**

![](https://cdn-learn.adafruit.com/assets/assets/000/023/924/medium800/led_matrix_cable1.png?1426546582)

 **Either end of the ribbon cable can be plugged into the matrix INPUT socket.**

The free end of the ribbon can point toward the center of the matrix, or hang off the side…the pinout is still the same. Notice below the direction of the “key” doesn’t change.

![](https://cdn-learn.adafruit.com/assets/assets/000/023/928/medium800/led_matrix_ribbon-2ways.png?1426548204)

A dual-row header gets installed on the proto shield, similar to the connector on the matrix. Just like the ribbon cable lying flat, as long as these two headers are _aligned the same way,_ they’ll  **match pin-for-pin** ; unlike the jumper wire method from the prior page, mirroring doesn’t happen.

![](https://cdn-learn.adafruit.com/assets/assets/000/023/939/medium800/led_matrix_aligned.png?1426554087)

Wires are then soldered from the header to specific Arduino pins on the proto shield. Try to keep wire lengths reasonably short to avoid signal interference.

Using color-coded wires helps a _lot!_ If you don’t have colored wires, that’s okay, just pay close attention where everything goes. Our goal is a proto shield something like this:

![](https://cdn-learn.adafruit.com/assets/assets/000/023/930/medium800/led_matrix_proto-example.jpg?1426549088)

It’s not necessary to install all the buttons and lights on the proto shield if you don’t want — just the basic header pins are sufficient.

For **Arduino form-factor boards** , using an [**Adafruit** proto shield](https://www.adafruit.com/product/2077): **if using a shrouded socket (like on the back of the matrix — with the notch so a ribbon cable only fits one way) you’ll need to place this near the “Reset” end of the shield.** The plastic shroud obscures a lot of pins. **Others’ proto shields may be laid out different** …look around for a good location before committing to solder.

For **Arduino Mega** with our [corresponding proto shield](https://www.adafruit.com/products/192): a shrouded socket fits best near the **middle** of the shield.

**Otherwise, you can use a plain 2x8-pin male header, or two 1x8 sections** installed side-by-side (as in the photo above). Since there’s no alignment key with this setup, you might want to indicate it with some tape or a permanent marker.

Depending on the make and model of proto shield, some pins are designed to connect in short rows. Others don’t. For the latter, strip a little extra insulation and bend the wire to wrap around the leg of the socket from behind, then solder.

![led_matrix_backside.jpg](https://cdn-learn.adafruit.com/assets/assets/000/023/940/medium640/led_matrix_backside.jpg?1426560083)

# Connect Ground Wires
 **32x32** and **64x32** matrices require **three ** ground connections. **32x16** matrices have **four**.

 

Most proto shields have _tons_ of grounding points, so you shouldn’t have trouble finding places to connect these.

![led_matrix_header-gnds.png](https://cdn-learn.adafruit.com/assets/assets/000/023/942/medium640/led_matrix_header-gnds.png?1426568010)

# Upper RGB Data
Pins **R1** , **G1** and **B1** (labeled R0, B0 and G0 on some matrices) deliver data to the **top half** of the display.

On the **Arduino Uno** and **Adafruit Metro (328, M0** or **M4) **boards, connect these to digital pins **2** , **3** and **4**.

On **Arduino Mega** , connect to pins **24** , **25** and  **26**.

![led_matrix_header-rgb1.png](https://cdn-learn.adafruit.com/assets/assets/000/023/943/medium640/led_matrix_header-rgb1.png?1426565078)

# Lower RGB Data
Pins **R2** , **G2** and **B2** (labeled R1, G1 and B1 on some matrices) deliver data to the **bottom half ** of the display. These connect to the next three Arduino pins…

On **Arduino Uno** and  **Adafruit Metros** , that’s pins **5** , **6** and **7**.

On **Arduino Mega** , pins **27** , **28** and **29**.

![led_matrix_header-rgb2.png](https://cdn-learn.adafruit.com/assets/assets/000/023/944/medium640/led_matrix_header-rgb2.png?1426580512)

# Row Select Lines
Pins **A** , **B** , **C** and **D** select which two rows of the display are currently lit. ( **32x16 matrices don’t have a “D” pin** — it’s connected to **ground ** instead.)

 

These connect to pins **A0** , **A1** , **A2** and (if D pin present) **A3**. This is the **same**  for both the  **Arduino Uno** and **Mega**.

![led_matrix_header-rows.png](https://cdn-learn.adafruit.com/assets/assets/000/023/945/medium640/led_matrix_header-rows.png?1426580569)

# LAT Wire
For **32x32** and **64x32** matrices, **LAT** connects to Arduino pin **10**.

This is the same for all boards.

The LAT (latch) signal marks the end of a row of data.

![led_matrix_header-lat.png](https://cdn-learn.adafruit.com/assets/assets/000/023/946/medium640/led_matrix_header-lat.png?1426565395)

# OE Wire
 **OE** connects to Arduino pin **9**. This is the same for all boards.

OE (output enable) switches the LEDs off when transitioning from one row to the next.

![led_matrix_header-oe.png](https://cdn-learn.adafruit.com/assets/assets/000/023/948/medium640/led_matrix_header-oe.png?1426565436)

# CLK Wire

Last one!

 **CLK** connects to…

- **Pin 8** on **Arduino Uno** , **Adafruit Metro 328** or **Metro M0**.
- **Pin A4** on **Adafruit Metro M4**.
- **Pin 11** on **Arduino Mega**.

The CLK (clock) signal marks the arrival of each bit of data.

![led_matrix_header-clk.png](https://cdn-learn.adafruit.com/assets/assets/000/023/947/medium640/led_matrix_header-clk.png?1426565431)

Here’s that photo again of a completed shield. You can tell this is for a 32x16 matrix, because there are four ground connections (one of the long vertical strips is a ground bus — see the tiny jumpers there?).

The ribbon cable to the matrix would plug into this with the key facing left.

The colors and positions don’t quite match the examples above, but are close. G1 and G2 are yellow wires. LAT is the purple wire and should go to pin 10 now (we changed around some things in the Arduino library).

![](https://cdn-learn.adafruit.com/assets/assets/000/023/949/medium800/led_matrix_proto-example.jpg?1426565584)

# RGB LED Matrix Basics

## Test Example Code

We have example code ready to go for these displays. It does not work with every board out there. **See the “Compatible Hardware” lists on the opening page for guidance.**

Danger: 

Danger: 

 **Support for 32-bit microcontrollers — M4, RP2040, ESP32, etc. — is documented in** [a different library called _Protomatter,_ documented here](https://learn.adafruit.com/adafruit-protomatter-rgb-matrix-library) **.**

 **Arduino Uno support is limited to the 32x16 matrix, and only “single-buffered”** (i.e. no smooth animation), _despite_ any comments in the examples that might suggest otherwise.

_Over time, RAM required by the core Arduino code and the matrix-driving graphics libraries has increased…a few bytes here and there as bugs are fixed and features are added. Early on, 32x32 (or double-buffered 32x16)_ just barely _fit in the Arduino Uno’s RAM, with a few dozen bytes to spare for user code. This is no longer the case. But you might still see references to this in older code._

Some libraries need to be downloaded and installed: first is the [RGB Matrix Panel library](https://github.com/adafruit/RGB-matrix-Panel) (this contains the low-level code specific to this device), then the [Adafruit GFX Library](https://github.com/adafruit/Adafruit-GFX-Library) (which handles graphics operations common to many displays we carry) and [Adafruit BusIO](https://github.com/adafruit/Adafruit_BusIO).

Both libraries can be found and installed using the Arduino Library Manager ( **Sketch→Include Library→Manage Libraries…** ). Search for “gfx” and “rgb matrix panel” and install the corresponding Adafruit libraries.

![led_matrices_lib-gfx.png](https://cdn-learn.adafruit.com/assets/assets/000/056/430/medium640/led_matrices_lib-gfx.png?1530127536)

![led_matrices_lib-matrix.png](https://cdn-learn.adafruit.com/assets/assets/000/056/431/medium640/led_matrices_lib-matrix.png?1530127547)

Now you are ready to test! Open up the IDE and load **File→Examples→RGBmatrixPanel→testcolors\_16x32** (for the 16x32 panel) or **File→Examples→RGBmatrixPanel→colorwheel\_32x32** (for the 32x32 panel). There’s also a  **testshapes\_32x64** example for boards with sufficient RAM.

**If using an Arduino Mega 2560,** in addition to wiring changes previously mentioned, you'll need to make a small change to each of the example sketches. This line:

```
#define CLK 8  // MUST be on PORTB! (Use pin 11 on Mega)
```

Should be changed to:

```
#define CLK 11
```

_(Any of digital pins 10-13 and 50-53 can be used for this function on the Mega, with the corresponding wiring change. The examples all reference pin 11.)_

If using an **Adafruit Metro M4** (_not_ M0 or 328), the CLK change would instead be:

```
#define CLK A4
```

After uploading, with the 16x32 panel you should see the following:

![](https://cdn-learn.adafruit.com/assets/assets/000/002/959/medium800/led_matrix_allcolors.jpg?1396789390)

This is a test pattern that shows 512 colors (out of 4096) on the 512 pixels. Since there's no really elegant way to show a 3-dimensional color space (R/G/B) in two dimensions, there's just repeating grids of red/green with increasing blue. Anyways, this shows you the range of colors you can achieve!  
  
or, with the 32x32 panel:  
![](https://cdn-learn.adafruit.com/assets/assets/000/002/960/medium800/led_matrix_rgbmatrix3232wheel_lrg.jpg?1396789401)

Now that you've got it working here are a few things to look for:  
  
The most useful line to look at is:  
```
      matrix.drawPixel(x, y, matrix.Color333(r, g, b));
```

which is where we actually draw to the display. This code only draws one pixel at a time. The **x** and **y** coordinates are the individual pixels of the display. **(0,0)** is in the top left corner, **(31, 15)** is in the bottom right (remember that we start counting at 0 here!). To create a color, you will want to use the helper funciton **Color333** which will take three 3-bit numbers and combine them into a single packed integer. So for example, the first argument, **r** can range from 0 to 7. Likewise for **g** and **b**. To make a pixel that is pure red, **r** would be 7 and **g, b** would be 0. To make a white pixel, set all to 7. To make a black (off) pixel, set the colors to 0. A similar function, **Color444** , accepts three 4-bit numbers for up to 4096 colors.  
  
Now we can open up the next example, which shows the rest of the library capabilities.

# RGB LED Matrix Basics

## RGBMatrix Library

Next up, load the **testshapes\_16x32** or **testshapes\_32x32** example sketch, which will test every drawing element available (again, you may need to edit the pin numbers for the 32x32 panel).

![](https://cdn-learn.adafruit.com/assets/assets/000/002/961/medium800/led_matrix_matrixshapes.jpg?1396789410)

The most simple thing you may want to do is draw a single pixel, we saw this introduced above.```
  // draw a pixel in solid white
  matrix.drawPixel(0, 0, matrix.Color333(7, 7, 7));
```

Next we will fill the screen with green by drawing a really large rectangle. The first two arguments are the top left point, then the width in pixels, and the height in pixels, finally the color```
  // fix the screen with green
  matrix.fillRect(0, 0, 32, 16, matrix.Color333(0, 7, 0));
```

Next we will draw just the outline of a rectangle, in yellow```
 // draw a box in yellow
  matrix.drawRect(0, 0, 32, 16, matrix.Color333(7, 7, 0));
```

Next you may want to draw lines. The **drawLine** procedure will draw a line in any color you want, we used this to draw a big X

```
  // draw an 'X' in red
  matrix.drawLine(0, 0, 31, 15, matrix.Color333(7, 0, 0));
  matrix.drawLine(31, 0, 0, 15, matrix.Color333(7, 0, 0));
```

The next shapes we draw are circles. You can draw the outline of a circle with **drawCircle** or fill a circle with **fillCircle**. The first two arguments are the center point, the third argument is the radius in pixels, finally the color to use.

```
  // draw a blue circle
  matrix.drawCircle(7, 7, 7, matrix.Color333(0, 0, 7));
 
  // fill a violet circle
  matrix.fillCircle(23, 7, 7, matrix.Color333(7, 0, 7));
```

 **fillScreen** allows you to fill the entire screen with a single color:

```
// fill the screen with 'black'
  matrix.fillScreen(matrix.Color333(0, 0, 0));
```

Finally, we draw the text that is shown up top as the demonstration image. We can use the **print** function, which you'll be familiar with from **Serial**. You can use **print** to print strings, numbers, variables, etc. However, we need to set up the printing before just going off and doing it! First, we must set the cursor location with **setCursor** which is where the top left pixel of the first character will go, this can be anywhere but note that text characters are 8 pixels high by default. Next **setTextSize** lets you set the size to 1 (8 pixel high) or 2 (16 pixel high for really big text!), you probably want just to stick with 1 for now. Lastly we can set the color of the text with **setTextColor**. Once this is all done, we can just use**print('1')** to print the character "1".

```
  // draw some text!
  matrix.setCursor(1, 0);   // start at top left, with one pixel of spacing
  matrix.setTextSize(1);    // size 1 == 8 pixels high
 
  // print each letter with a rainbow color
  matrix.setTextColor(matrix.Color333(7,0,0));
  matrix.print('1');
  matrix.setTextColor(matrix.Color333(7,4,0)); 
  matrix.print('6');
  matrix.setTextColor(matrix.Color333(7,7,0));
  matrix.print('x');
  matrix.setTextColor(matrix.Color333(4,7,0)); 
  matrix.print('3');
  matrix.setTextColor(matrix.Color333(0,7,0));  
  matrix.print('2');
 
  matrix.setCursor(1, 9);   // next line
  matrix.setTextColor(matrix.Color333(0,7,7)); 
  matrix.print('*');
  matrix.setTextColor(matrix.Color333(0,4,7)); 
  matrix.print('R');
  matrix.setTextColor(matrix.Color333(0,0,7));
  matrix.print('G');
  matrix.setTextColor(matrix.Color333(4,0,7)); 
  matrix.print("B");
  matrix.setTextColor(matrix.Color333(7,0,4)); 
  matrix.print("*");
```

![](https://cdn-learn.adafruit.com/assets/assets/000/002/962/medium800/led_matrix_rgbmatrix.jpg?1396789420)

# RGB LED Matrix Basics

## How the Matrix Works

There's no “official” documention out there on how these matrices work, and no public datasheets or spec sheets so we are going to try to document how they work.  
  
First thing to notice is that there are 512 RGB LEDs in a 16x32 matrix. Like pretty much every matrix out there, **you can't drive all 512 at once**. One reason is that would require a lot of current, another reason is that it would be really expensive to have so many pins. Instead, the matrix is divided into 8 interleaved sections/strips. The first section is the 1st 'line' and the 9th 'line' (32 x 2 RGB LEDs = 64 RGB LEDs), the second is the 2nd and 10th line, etc until the last section which is the 8th and 16th line. You might be asking, why are the lines paired this way? wouldnt it be nicer to have the first section be the 1st and 2nd line, then 3rd and 4th, until the 15th and 16th? The reason they do it this way is so that the lines are interleaved and look better when refreshed, otherwise we'd see the stripes more clearly.  
  
So, on the PCB are 12 LED driver chips. These are like 74HC595s but they have 16 outputs and they are constant current. 16 outputs \* 12 chips = 192 LEDs that can be controlled at once, and 64 \* 3 (R G and B) = 192. So now the design comes together: You have 192 outputs that can control one line at a time, with each of 192 R, G and B LEDs either on or off. The controller (say an FPGA or microcontroller) selects which section to currently draw (using A, B, and C address pins - 3 bits can have 8 values). Once the address is set, the controller clocks out 192 bits of data (24 bytes) and latches it. Then it increments the address and clocks out another 192 bits, etc until it gets to address #7, then it sets the address back to #0  
  
The only downside of this technique is that despite being very simple and fast, it has **no PWM control** built in! The controller can **only** set the LEDs **on or off**. So what do you do when you want full color? You actually need to draw the entire matrix over and over again at very high speeds to PWM the matrix manually. For that reason, you need to have a very fast controller (50 MHz is a minimum) if you want to do a lot of colors and motion video and have it look good.  
  
How quickly can we feed data to the matrix? Forum users Andrew Silverman and Ryan Brown have been [posting their progress](http://forums.adafruit.com/viewtopic.php?f=47&t=26130&start=0) driving the 16x32 matrix with an FPGA, and the limit appears to be somewhere between 40 and 50 MHz. Ryan writes: “I haven't validated 100% pixel correctness, but 50 MHz seems to work for me […] 67MHz definitely did not work.” He also provided this graph showing current draw relative to clock frequency:

![](https://cdn-learn.adafruit.com/assets/assets/000/002/965/medium800/led_matrix_16x32ledmatrixcurrent.png?1396789475)

_Image above by rhb.me (CC By-NC-SA)_  
  
“Notice that the LED panel current consumption decreases as clock frequency increases. This suggests that the LED ‘on time’ is decreasing. I’m guessing this is caused by frequency-invariant delays in the LED driver shift registers.”# RGB LED Matrix Basics

## FAQ

### I'm seeing weird pixel artifacts, ghosting, or other glitches.

This will probably be due to one of these:

- Wiring
- Power
- Software
- Bad display

Wiring problems are probably the biggest source of display issues. Especially if you are attempting the "jumper wire" connection method. There have also been cases of power supplies causing interference. This guide covers both proper wiring and power.

 

If all of that seems OK and you are still seeing weird pixels, it may be due to how the pixels are being driven in software. You can try some tweaks as covered in the guide, but the issue may not entirely go away.

 

If you've tried to troubleshoot and still have issues, post in the forums and we can take a look. Every now and then a display can just be bad.

 

## Wiring Issue Examples

Wiring issues tend to look like this and are often fixable if you can find the wrong / bad wire.

![](https://cdn-learn.adafruit.com/assets/assets/000/074/803/medium800/led_matrices_wiring1.jpg?1555976239)

![](https://cdn-learn.adafruit.com/assets/assets/000/074/805/medium800/led_matrices_wiring2.jpg?1555976264)

## Ghosting Issue Examples

You see what you expect for the most part, but also some other artifacts. This can happen even with proper wiring.

![](https://cdn-learn.adafruit.com/assets/assets/000/074/800/medium800/led_matrices_ghost2.jpg?1555976219)

![](https://cdn-learn.adafruit.com/assets/assets/000/074/802/medium800/led_matrices_ghost1.jpg?1555976230)

### Why are green and blue are reversed on my 2.5mm panel?

On the 64x32 2.5mm panels (product ID [5036](https://www.adafruit.com/product/5036)), the green and blue channels are swapped compared to the standard HUB75 pinout. When using with libraries, simply swap the pin numbers for G1, G2 with B1, B2 in software to flip them back around.

If you are using the CircuitPython `MatrixPortal` library, you do not need to swap pins explicitly. Instead, add this argument to the constructor: `MatrixPortal(..., color_order="RBG", ...)`. The default order is `"RGB"`, and this argument will swap the pins to match the specified `"RBG"` order.

# RGB LED Matrix Basics

## Downloads

# Files

- [Fritzing object in the Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library)
- [EagleCAD PCB Files in GitHub](https://github.com/adafruit/Adafruit-RGB-Matrix-Shield-PCB)

# Schematic and Fab Print for Partially Assembled Version
![](https://cdn-learn.adafruit.com/assets/assets/000/120/968/medium800/led_matrices_RGBMS_sch.png?1683910298)

![](https://cdn-learn.adafruit.com/assets/assets/000/120/967/medium800/led_matrices_RGBMS_fab_print.png?1683910279)

# Schematic & Fabrication Print Original Version
![](https://cdn-learn.adafruit.com/assets/assets/000/057/230/medium800/led_matrices_schem.png?1530986712)

![](https://cdn-learn.adafruit.com/assets/assets/000/057/231/medium800/led_matrices_fabprint.png?1530986721)


## Featured Products

### Medium 16x32 RGB LED matrix panel - 6mm Pitch

[Medium 16x32 RGB LED matrix panel - 6mm Pitch](https://www.adafruit.com/product/420)
Bring a little bit of Times Square into your home with this 16 x 32 RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked really cool so we...

In Stock
[Buy Now](https://www.adafruit.com/product/420)
[Related Guides to the Product](https://learn.adafruit.com/products/420/guides)
### 32x32 RGB LED Matrix Panel - 4mm Pitch

[32x32 RGB LED Matrix Panel - 4mm Pitch](https://www.adafruit.com/product/607)
Bring a little bit of Times Square into your home with this totally adorable 5 inch square 32 x 32 RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought...

In Stock
[Buy Now](https://www.adafruit.com/product/607)
[Related Guides to the Product](https://learn.adafruit.com/products/607/guides)
### 32x32 RGB LED Matrix Panel - 5mm Pitch

[32x32 RGB LED Matrix Panel - 5mm Pitch](https://www.adafruit.com/product/2026)
Bring a little bit of Times Square into your home with this sweet 32 x 32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked...

In Stock
[Buy Now](https://www.adafruit.com/product/2026)
[Related Guides to the Product](https://learn.adafruit.com/products/2026/guides)
### 32x32 RGB LED Matrix Panel - 6mm pitch

[32x32 RGB LED Matrix Panel - 6mm pitch](https://www.adafruit.com/product/1484)
Bring a little bit of Times Square into your home with this sweet 32 x 32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked...

In Stock
[Buy Now](https://www.adafruit.com/product/1484)
[Related Guides to the Product](https://learn.adafruit.com/products/1484/guides)
### 64x32 RGB LED Matrix - 3mm pitch

[64x32 RGB LED Matrix - 3mm pitch](https://www.adafruit.com/product/2279)
Bring a little bit of Times Square into your home with this sweet 64 x 32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked...

In Stock
[Buy Now](https://www.adafruit.com/product/2279)
[Related Guides to the Product](https://learn.adafruit.com/products/2279/guides)
### 64x32 RGB LED Matrix - 4mm pitch

[64x32 RGB LED Matrix - 4mm pitch](https://www.adafruit.com/product/2278)
Bring a little bit of Times Square into your home with this sweet 64 x 32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked...

In Stock
[Buy Now](https://www.adafruit.com/product/2278)
[Related Guides to the Product](https://learn.adafruit.com/products/2278/guides)
### 64x32 RGB LED Matrix - 5mm pitch

[64x32 RGB LED Matrix - 5mm pitch](https://www.adafruit.com/product/2277)
Bring a little bit of Times Square into your home with this sweet 64x32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked really...

In Stock
[Buy Now](https://www.adafruit.com/product/2277)
[Related Guides to the Product](https://learn.adafruit.com/products/2277/guides)
### 64x32 RGB LED Matrix - 6mm pitch

[64x32 RGB LED Matrix - 6mm pitch](https://www.adafruit.com/product/2276)
Bring a little bit of Times Square into your home with this sweet 64x32 square RGB LED matrix panel. These panels are normally used to make video walls, here in New York we see them on the sides of busses and bus stops, to display animations or short video clips. We thought they looked really...

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

## Related Guides

- [Adafruit Metro M0 Express](https://learn.adafruit.com/adafruit-metro-m0-express.md)
- [Adafruit Metro M4 Express featuring ATSAMD51](https://learn.adafruit.com/adafruit-metro-m4-express-featuring-atsamd51.md)
- [Purple Air AQI Display](https://learn.adafruit.com/purple-air-aqi-display.md)
- [Matrix Portal Scoreboard](https://learn.adafruit.com/matrix-portal-scoreboard.md)
- [How to Build a Testing Jig](https://learn.adafruit.com/how-to-build-a-testing-fixture.md)
- [Adafruit Protomatter RGB Matrix Library](https://learn.adafruit.com/adafruit-protomatter-rgb-matrix-library.md)
- [Sous-vide controller powered by Arduino - The SousViduino!](https://learn.adafruit.com/sous-vide-powered-by-arduino-the-sous-viduino.md)
- [Adding a WiFi Co-Processor to CircuitPython](https://learn.adafruit.com/adding-a-wifi-co-processor-to-circuitpython-esp8266-esp32.md)
- [Adafruit AirLift Shield - ESP32 WiFi Co-Processor](https://learn.adafruit.com/adafruit-airlift-shield-esp32-wifi-co-processor.md)
- [Moon Phase Clock for Adafruit Matrix Portal](https://learn.adafruit.com/moon-phase-clock-for-adafruit-matrixportal.md)
- [RGB LED Matrices with CircuitPython](https://learn.adafruit.com/rgb-led-matrices-matrix-panels-with-circuitpython.md)
- [Adafruit RGB Matrix + Real Time Clock HAT for Raspberry Pi](https://learn.adafruit.com/adafruit-rgb-matrix-plus-real-time-clock-hat-for-raspberry-pi.md)
- [Using Python on Windows 10](https://learn.adafruit.com/using-python-on-windows-10.md)
- [Adafruit Optical Fingerprint Sensor](https://learn.adafruit.com/adafruit-optical-fingerprint-sensor.md)
- [Sending an SMS with Temboo](https://learn.adafruit.com/sending-an-sms-with-temboo.md)
- [Adafruit RGB Matrix FeatherWings](https://learn.adafruit.com/rgb-matrix-featherwing.md)
- [Circle of Fifths Euclidean Synth with synthio and CircuitPython](https://learn.adafruit.com/circle-of-fifths-euclidean-synth-with-synthio-and-circuitpython.md)