# Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Overview ![Adafruit Trip Matrix Bonnet driving 3 HUB75 compatible RGB matrices ](https://cdn-learn.adafruit.com/assets/assets/000/138/249/medium800thumb/led_matrices_triplematrix_rainbowspiral.jpg?1752008930 ) You can now create large, dazzling LED matrix displays with your Raspberry Pi with the **Adafruit Triple Matrix Bonnet for Raspberry Pi.** This boards plugs into your Raspberry Pi with 2x20 header, and makes it super easy to control three parallel strings of HUB75 RGB matrices such as those we stock in the shop and create colorful scrolling displays or mini LED walls with ease.  ![Adafruit Trip Matrix Bonnet](https://cdn-learn.adafruit.com/assets/assets/000/138/250/medium800/led_matrices_triplematrix_main_topdown.jpg?1752008995 ) [Unlike our single-panel Matrix Bonnet](https://www.adafruit.com/product/3211), this board can drive 3 panels in parallel, also known as "active3" pinout. This means it can handle approximately 3x as many panels/pixels. However, as a trade-off, the **power management is not done on-board. Instead you will have to provide the 5V 10A+ power separately! [We recommend two power distribution bus bars](https://www.adafruit.com/product/737),** they're good for many amps and make wiring easier. ![Adafruit Trip Matrix Bonnet bottom side with Raspberry Pi 2x20 header pin connector.](https://cdn-learn.adafruit.com/assets/assets/000/138/251/medium800/led_matrices_triplematrix_main_bottom.jpg?1752009205 ) - **"Bonnet" boards work on Raspberry Pi with a 40-pin GPIO header — Zero, Zero W/WH, Model A+, B+, Pi 2, Pi 3, Pi 4, Pi 5 ** They _do not work_ with older 26-pin boards like the original Model A or B. Note with the Pi Zero, you may need to solder a header on the Pi board; it’s normally unpopulated on that model. For best performance we recommend a Pi 4 or Pi 5. - **For Pi 0, 2, 3, and 4** we recommend the [rpi-rgb-matrix driver](https://github.com/hzeller/rpi-rgb-led-matrix), with C and Python bindings. It works great, just select the _standard/active3_ pinout. - For Pi 5+, [we recommend using our PIO-based matrix driver](https://learn.adafruit.com/rgb-matrix-panels-with-raspberry-pi-5) which supports up to 3 panels - check the guide for the demo code for the triple bonnet - By default the bonnet has a slim 2x20 header on it. If you need to 'lift' the bonnet above an enclosure, [pick up a 2x20 riser header](https://www.adafruit.com/product/4079).  - If you want to get access to GPIO while the bonnet is installed, [pick up a 2x20 stacking header](https://www.adafruit.com/product/2223) - the pins will slide through the socket and you can plug something else on top. ![Adafruit Trip Matrix Bonnet](https://cdn-learn.adafruit.com/assets/assets/000/138/253/medium800/led_matrices_triplematrix_top_angle.jpg?1752009344 ) This bonnet will make your mega-matrix projects super easy and avoid wiring complexity and mistakes: - **Simple design**  - plug in IDC cables, provide separate power to each panel, run our Python code! - **Onboard level shifters**  to convert the RasPi's 3.3V to 5.0V logic for clean and glitch free matrix driving - **Fully assembled compact design** no soldering required! Plugs onto any Raspberry Pi with a 2x20 connector, and you're ready to glow. ![Adafruit Trip Matrix Bonnet connected to Raspberry Pi](https://cdn-learn.adafruit.com/assets/assets/000/138/265/medium800/led_matrices_triplematrix_onpi_top_angle.jpg?1752068058 ) Works with any of our [16x32, 32x32, 32x64, or 64x64 RGB LED Matrices with HUB75 connections](https://www.adafruit.com/categories/327). When using with 64x64 you can select whether the Address E pin is on the 4th or 8th IDC pad with an on-board switch. Want even _more lights? _No problem, chain multiple matrices together for a longer display. The bigger the display the harder it is on the Pi, so keep that in mind if you're using a lower-powered Pi Zero. **Please note:**  this Bonnet is only for use with HUB75 type RGB matrices. Not for use with NeoPixel, DotStar, or other 'addressable' LEDs. Each order comes with a fully assembled and ready to go bonnet with all parts assembled. [**RGB Matrix is not included** , please check out our fine selection](https://www.adafruit.com/categories/327) **A serious 5V power supply is also required, not included,**  for power the matrix itself; the Pi cannot do it, to calculate the power, multiply the width of all the chained matrices \* 0.12 Amps : A 32 pixel wide matrix can end up drawing 32\*0.12 = 3.85A **per panel** so we recommend [a 5V 10A power supply](https://www.adafruit.com/product/658). Actual power usage will vary with how many LEDs you light up at once. **Raspberry Pi not included**  [(but we have 'em in the shop so pick one up! Pi 5 is recommended as its the newest, but Pi 4 will also work well)](https://www.adafruit.com/categories/176) **Cables** - all Adafruit HUB75 displays come with a data cable and a power cable. If you get a display from somewhere else you might not get such cables. Adafruit carries the [8x2 data cable](https://www.adafruit.com/product/4170) and the [5V power cable](https://www.adafruit.com/product/4767) if you need them. ![Adafruit Trip Matrix Bonnet on Raspberry Pi wired up to 3 HUB75 matrix panels and power cables connected to the panels.](https://cdn-learn.adafruit.com/assets/assets/000/138/266/medium800/led_matrices_triplematrix_wiredup.jpg?1752068286 ) # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Pinouts ![Adafruit Trip Matrix Bonnet bottom side with pins labeled on the silkscreen](https://cdn-learn.adafruit.com/assets/assets/000/138/268/medium800/led_matrices_triplematrix_main_bottom.jpg?1752068519 ) ## Matrix Power Requirements The **power management is not done on-board. Instead you will have to provide the 5V 10A+ power separately! [We recommend two power distribution bus bars](https://www.adafruit.com/product/737)**, they're good for many amps and make wiring easier. LED matrix panels require 5V power and **a lot of it!** [5V 2A](https://www.adafruit.com/product/276) at a minimum and you can easily need a [5V 4A](https://www.adafruit.com/product/1466) or [5V 10A](https://www.adafruit.com/product/658) supply for big stretches of panels! Each matrix has 64 pixels (16x32 or 32x32 panels) or 128 pixels (for the 32x64 panels) lit at one time (due to “scanning” the rows sequentially). Each pixel can briefly draw up to 0.06 Amps each if on full white. The total max per panel is thus **64 \* 0.06 = 3.95 Amps** or **128 \* 0.06 = 7.68 Amps** That's if all the LEDs are on at once, which is not likely - but still, it's good to have at least half for the power supply in case you get bright! ## Matrix Drive Pins The matrix does not work like 'smart' pixels you may have used, like NeoPixels or DotStars or LPD8806 or WS2801 or what have you. The matrix panels are very 'dumb' and have no memory or self-drawing capability. Data must be constantly streamed to the matrix for an image to display! So all of these pins are always used when drawing to the display All these pins go thru a 74AHCT245 level shifter to convert the 3.3V logic from the Pi to the 5V logic required by the panels ### Shared Pins The matrix control pins, and address pins are shared between all 3 of the ports. ![Adafruit Trip Matrix Bonnet with shared address and control pin numbers highlighted](https://cdn-learn.adafruit.com/assets/assets/000/138/271/medium800/led_matrices_sharedpins_highlights.png?1752071110 ) **Control Pins:** - Pi GPIO **#18 - Matrix OE** (output enable) pin This pin controls whether the LEDs are lit at all - Pi GPIO **#17 - Matrix CLK** (clock) pin This pin is the high speed clock pin for clocking RGB data to the matrix - Pi GPIO **#4 - Matrix LAT** (latch) pin This pin is the data latching pin for clocking RGB data to the matrix **Address Pins:** - Pi GPIO **#22 - Matrix A** (address A) pin This pin is part of the 1-\>32, 1-\>16 or 1-\>8 multiplexing circuitry. - Pi GPIO **#23 - Matrix B** (address B) pin This pin is part of the 1-\>32, 1-\>16 or 1-\>8 multiplexing circuitry. - Pi GPIO **#24 - Matrix C** (address C) pin This pin is part of the 1-\>32, 1-\>16 or 1-\>8 multiplexing circuitry. - Pi GPIO **#25 - Matrix D** (address D) pin This pin is part of the 1-\>32, 1-\>16 multiplexing circuitry. Used for 32-pixel and 64-pixel tall displays only - Pi GPIO **#15/RxD - Matrix E** (address E) pin This pin is part of the 1-\>32 multiplexing circuitry. Used for 64-pixel tall displays only.  **Behavior is controlled by the slide switch. See below for details.** ### Port 1 Matrix Color Pins - Pi GPIO  **#11 - Matrix R1** (Red row 1) pin This pin controls the red LEDs on the top half of the display - Pi GPIO  **#27 - Matrix G1** (Green row 1) pin This pin controls the green LEDs on the top half of the display - Pi GPIO  **#7 - Matrix B1** (Blue row 1) pin This pin controls the blue LEDs on the top half of the display - Pi GPIO  **#8 - Matrix R2** (Red row 2) pin This pin controls the red LEDs on the bottom half of the display - Pi GPIO **#9 - Matrix G2** (Green row2) pin This pin controls the green LEDs on the bottom half of the display - Pi GPIO **#10 - Matrix B2** (Blue row 2) pin This pin controls the blue LEDs on the bottom half of the display ![Adafruit Trip Matrix Bonnet with port 1 pins highlighted](https://cdn-learn.adafruit.com/assets/assets/000/138/269/medium640/led_matrices_port1_highlights.png?1752070272) ### Port 2 Matrix Color Pins - Pi GPIO  **#12 - Matrix R1** (Red row 1) pin This pin controls the red LEDs on the top half of the display - Pi GPIO  **#5 - Matrix G1** (Green row 1) pin This pin controls the green LEDs on the top half of the display - Pi GPIO  **#6 - Matrix B1** (Blue row 1) pin This pin controls the blue LEDs on the top half of the display - Pi GPIO  **#19 - Matrix R2** (Red row 2) pin This pin controls the red LEDs on the bottom half of the display - Pi GPIO **#13 - Matrix G2** (Green row2) pin This pin controls the green LEDs on the bottom half of the display - Pi GPIO **#20 - Matrix B2** (Blue row 2) pin This pin controls the blue LEDs on the bottom half of the display ![Adafruit Trip Matrix Bonnet with port 2 pins highlighted](https://cdn-learn.adafruit.com/assets/assets/000/138/272/medium640/led_matrices_port2_highlights.png?1752071537) ### Port 3 Matrix Color Pins - Pi GPIO  **#14/TxD - Matrix R1** (Red row 1) pin This pin controls the red LEDs on the top half of the display - Pi GPIO  **#2/SCL - Matrix G1** (Green row 1) pin This pin controls the green LEDs on the top half of the display - Pi GPIO  **#3/SDA - Matrix B1** (Blue row 1) pin This pin controls the blue LEDs on the top half of the display - Pi GPIO  **#26 - Matrix R2** (Red row 2) pin This pin controls the red LEDs on the bottom half of the display - Pi GPIO **#16 - Matrix G2** (Green row2) pin This pin controls the green LEDs on the bottom half of the display - Pi GPIO **#21 - Matrix B2** (Blue row 2) pin This pin controls the blue LEDs on the bottom half of the display ![Adafruit Trip Matrix Bonnet with port 3 pins highlighted](https://cdn-learn.adafruit.com/assets/assets/000/138/273/medium640/led_matrices_port3_highlights.png?1752072145) ## Power Pins Addr E Switch & STEMMA QT In the lower left corner of the board there are some exposed power pins, a switch for controlling address E, and a STEMMA QT port. ![Adafruit Trip Matrix Bonnet with power pins, address E switch, and STEMMA port highlighted.](https://cdn-learn.adafruit.com/assets/assets/000/138/274/medium800/led_matrices_power_arddreswitch_stemma.png?1752073207 ) ### Power Pins - **5 - 5V ** power - **3 - 3V** power - **G - GND** ### Address E Switch When using with 64x64 matrices, you can select whether the Address E pin is on the 4th or 8th IDC pad with this on-board switch. If your panels aren't displaying properly, try switching this to the other position. ### STEMMA QT There is a STEMMA QT port available, but keep in mind the  **SDA** and **SCL** pins are also used by Matrix port 3, so you cannot use both at the same time. # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Wiring # Step 1. Plug HAT/Bonnet into Raspberry Pi Shut down your Pi and remove power. Plug the Triple Matrix Bonnet on top so all the 2x20 pins go into the GPIO header. No soldering required. By default the bonnet has a slim 2x20 header on it. If you need to 'lift' the bonnet above an enclosure, [pick up a 2x20 riser header](https://www.adafruit.com/product/4079).  If you want to get access to GPIO while the bonnet is installed, [pick up a 2x20 stacking header](https://www.adafruit.com/product/2223) - the pins will slide through the socket and you can plug something else on top. ![Triple Matrix Bonnet on top of Raspberry Pi](https://cdn-learn.adafruit.com/assets/assets/000/138/386/medium640/led_matrices_triplematrix_onpi_top_angle.jpg?1752526459) # Step 2. Connect RGB Matrix Data cables to IDC The RGB matrix from Adafruit comes with a 2x8 data cable. Connect one end to the matrix INPUT side and the other end to the IDC socket on the HAT/bonnet. It won't damage the matrix if you accidentally get the cable connected to the output end of the matrix but it won't work so you might as well get it right first time! If you're using 3 panels placed next to each other, be sure to connect  **port 2**  to the **center panel**. Be careful not to put too much pressure onto the bonnet and Pi's GPIO pins while pushing in the matrix cables. Put a finger underneath the bonnet to support it as you press the the matrix cables into their connectors.  ![Triple Matrix Bonnet on top of Raspberry Pi with RGB matrix cables connected](https://cdn-learn.adafruit.com/assets/assets/000/138/387/medium640/led_matrices_triplematrix_cables_connected.png?1752528086) ![RGB Matrix panel with the other end of the cable connected to the input connector](https://cdn-learn.adafruit.com/assets/assets/000/138/389/medium640/led_matrices_matrix_cable_connected_to_panel.png?1752528659) # Step 3. Plug in the 5V DC power for the Matrices The standard power cables included with Adafruit matrix panels have two 4 pin connectors that can be connected to each of two different panels. To drive 3 panels you need two sets of these cables, and the last connector will be unused. **You need to provide 5V DC with at least 8-10+ amps!** Shown here wired with two [Female DC Power adapter screw terminal blocks](https://www.adafruit.com/product/368), ready to be connected to two [5V 4A power adapters](https://www.adafruit.com/product/1466). You can instead put both sets of power cable forks into one barrel jack and use a [5V 10A adapter](https://www.adafruit.com/product/658). If using your own wire, be sure it is heavy guage. Do not use breadboard wires, they're too small and will overheat. ![Triple Matrix Bonnet on top of Raspberry Pi connected to 3 matrix panels. Panels have power connectors plugged in to cables with barrel jacks ready for the adapter to be plugged in.](https://cdn-learn.adafruit.com/assets/assets/000/138/390/medium640/led_matrices_power_connected.png?1752529407) # Step 4. Log into your Pi to install and run software Now you are ready to install the RGB matrix driver software. You will need to get into a command line via the HDMI monitor, ssh or console cable. You will also need to make sure your Pi is on the Internet via a WiFi or Ethernet connection. For Raspberry Pi 4 and lower devices continue on to the next section. For [Raspberry Pi 5 skip to its section](https://learn.adafruit.com/adafruit-triple-led-matrix-bonnet-for-raspberry-pi-with-hub75/raspberry-pi-5-setup). # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Raspberry Pi 4 You will need to get into a command line via the HDMI monitor, ssh or console cable. You will also need to make sure your Pi is on the Internet via a WiFi or Ethernet connection. From the command line, use the following commands to run the installer script: ```terminal curl https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/main/rgb-matrix.sh >rgb-matrix.sh sudo bash rgb-matrix.sh ``` **The LED-matrix library is (c) Henner Zeller h.zeller@acm.org with GNU General Public License Version 2.0** [**http://www.gnu.org/licenses/gpl-2.0.txt**](http://www.gnu.org/licenses/gpl-2.0.txt) Earlier versions of this guide used our own fork of this library. That’s **deprecated** now, but [still available ](https://github.com/adafruit/rpi-rgb-led-matrix)if you have existing code built atop it. Otherwise, use this installer script and latest code. ![](https://cdn-learn.adafruit.com/assets/assets/000/137/891/medium800/led_matrices_script-1.png?1750274738 ) When first run, the script will explain its plans and give you the option to cancel. Of particular note here: any existing installation will be replaced. If there is a directory called “rpi-rgb-led-matrix” in the current working directory, its contents will be overwritten. If this is a problem, cancel and make a backup. Otherwise, sometimes reinstalling is exactly what you want. ![](https://cdn-learn.adafruit.com/assets/assets/000/137/892/medium800/led_matrices_script-2.png?1750274845 ) Next the script will ask you what kind of adapter you’re using between the Pi and RGB matrix: either an **Adafruit RGB Matrix Bonnet** , or **RGB Matrix HAT with RTC**. If you select the latter, you’ll also be asked if you want to install additional drivers for the realtime clock. If you are using the Adafruit Triple LED Matrix Bonnet then select **Adafruit RGB Matrix Bonnet**. ![](https://cdn-learn.adafruit.com/assets/assets/000/137/893/medium800/led_matrices_script-board.png?1750274890 ) Then you’re asked whether you need the _absolute best image possible_ from the LED matrix, or can accept slightly reduced quality for the sake of simplicity. **The "quality" setting requires soldering the GPIO4 and GPIO18 pins together.** See previous section for details. If you are using the **Adafruit Triple LED Matrix Bonnet** you should select **"quality"**. The **Adafruit Triple LED Matrix Bonnet** does not require any additional soldering. The single matrix bonnet and HAT require additional soldering for the quality choice. **The “convenience” setting requires no changes and sound still works.** For many casual projects this might look good enough. There’s an occasional bit of flicker from the matrix, that’s all. If you're using a single matrix bonnet or HAT, and you’re not sure, or if you just want to get started experimenting with your new gadget, select “convenience” for now. You can make the change and reinstall the software later if needed. ![](https://cdn-learn.adafruit.com/assets/assets/000/137/894/medium800/led_matrices_script-optimize.png?1750274898 ) The script will **confirm your selections** and offer **one more chance to cancel** without changes. There’s a lot of software to update, download and install, so it may take up to **15 minutes** or so to complete. Afterward, you’ll be asked whether you want to **reboot** the system. If you’ve selected to install RTC support (for the Matrix HAT + RTC) or have made a change in the “quality” vs “convenience” setting, a reboot is required. All other settings (LED matrix size, number of “chained” matrices and so forth) are specified at run-time. Danger: Overclocked Raspberry Pi boards may produce visual glitches on the LED matrix. If you encounter such trouble, first thing to try is to set the Pi to the default (non-overclocked) speed using raspi-config, then reboot and retest Once the Pi has rebooted, log back in and continue to the **Testing Install** section. # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Install Manually Warning: This information is for advanced users. It is recommended to use the installer script from the previous section. ## Install Prerequisites Make sure these are installed: ```terminal sudo apt-get install -y git python3-dev python3-pillow cython3 python3-setuptools ``` ## Source Code The code used to drive the matrices is found in this repo: [rpi-rgb-led-matrix](https://github.com/hzeller/rpi-rgb-led-matrix) There is good information found there in various README's and that might be all you need. The information that follows serves more as a general example of how to get the code and build the main targets. ## Clone and Build The project is makefile based, so it is fairly easy to clone the repo and build the target(s): ```terminal git clone https://github.com/hzeller/rpi-rgb-led-matrix.git cd rpi-rgb-led-matrix make ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/901/medium800/led_matrices_Screenshot_from_2025-06-19_10-42-03.png?1750354967 ) The default target builds the library as well as the C examples found in the `examples-api-use` subdirectory. It should be possible to run those examples after the build completes: ```terminal cd examples-api-use sudo ./demo -D 0 ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/902/medium800/led_matrices_Screenshot_from_2025-06-19_10-44-21.png?1750355115 ) ## Dealing with "quality" vs. "convenience" The default build uses a hardware subsystem on the Pi that is also used for audio on HDMI and the 1/8" jack. This is the "quality" option referred to by the installer script and it also requires connecting GPIO 4 to 18 on the HAT/Bonnet. **So there is a hardware resource conflict that must be resolved.** The demo programs will report this with the following message: ```terminal === snd_bcm2835: found that the Pi sound module is loaded. === Don't use the built-in sound of the Pi together with this lib; it is known to be incompatible and cause trouble and hangs (you can still use external USB sound adapters). See Troubleshooting section in README how to disable the sound module. You can also run with --led-no-hardware-pulse to avoid the incompatibility, but you will have more flicker. Exiting; fix the above first or use --led-no-hardware-pulse ``` The other option is to disable the hardware pulsing feature of the RGB matrix driver software. This is the "convenience" option referred to by the installer script. More info on these two options: ### Option 1: Disable Sound for Hardware Pulsing ("quality") To disable the Pi audio, blacklist it. Create a file named  **/etc/modprobe.d/blacklist-rgb-matrix.conf** with the contents: ```terminal blacklist snd_bcm2835 ``` and then reboot the Pi. ### Option 2: Disable Hardware Pulsing ("convenience") The command line parameter `--led-no-hardware-pulse` can be used to turn off this feature in the RGB matrix driver software at run time: ```terminal sudo ./demo --led-no-hardware-pulse -D 0 ``` It can also be disabled at build time using the DISABLE\_HARDWARE\_PULSES preprocessor directive:  ```terminal make USER_DEFINES="-DDISABLE_HARDWARE_PULSES" ``` ## Python Build There are two targets for this: `build-python` and `install-python`. The install target uses an older (setup.py) approach. However, it seems to generally work OK to create and activate a Python virtual environment and then use the `install-python` target: Info: Make is run here without sudo since we are installing into a local user directory, i.e. the venv. ```auto python3 -m venv test source test/bin/activate cd rpi-rgb-led-matrix make install-python ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/903/medium800/led_matrices_Screenshot_from_2025-06-19_11-00-44.png?1750356154 ) It also works to use the `build-python` target and then manually run setup.py with a virtual environment active. The `build-python` and `install-python` targets are dependent on the main library target, so if the goal is to have Python bindings, either of those can be used as the build target, i.e. just build everything in one make execution. # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Testing Install The installer creates a directory called `rpi-rgb-led-matrix`, and inside this is a subdirectory `examples-api-use` with a few programs we can use to experiment with the matrix and confirm everything’s working. Info: These are compiled C based stand alone examples that do not rely on Python. There's no need to worry about the "python bindings" or the "virtual environment" to run these. To run these examples, first change to the directory: ```terminal cd ~/rpi-rgb-led-matrix/examples-api-use/ ``` We'll use the `demo` program to test the setup. Here is an example for a **32x32 LED matrix**. Note the program must be run with `sudo`. ```terminal sudo ./demo --led-rows=32 --led-cols=32 --led-gpio-mapping=adafruit-hat -D 0 ``` Change the following parameters as needed for your setup: - `--led-row=` set this to the number of LEDs in each matrix row - `--led-cols=` set this to the number of LEDs in each matrix column - `--led-gpio-mapping=` set this to `adafruit-hat` or `adafruit-hat-pwm` for single matrix bonnet/HAT. For triple matrix bonnet use `regular` - `--led-parallel=` set this to `3` if you are using the triple matrix bonnet or other active3 compatible hardware. Otherwise it can be omitted. Running the `demo` program: ![](https://cdn-learn.adafruit.com/assets/assets/000/137/895/medium800/led_matrices_Screenshot_from_2025-06-18_13-01-39.png?1750276916 ) should result in a rotating square on the matrix: ![](https://cdn-learn.adafruit.com/assets/assets/000/137/896/medium800thumb/led_matrices_out.jpg?1750277660 ) The `-D` parameter picks the specific demo to run. There are several to choose from, some with additional parameters: ```terminal Demos, choosen with -D 0 - some rotating square 1 - forward scrolling an image (-m ) 2 - backward scrolling an image (-m ) 3 - test image: a square 4 - Pulsing color 5 - Grayscale Block 6 - Abelian sandpile model (-m ) 7 - Conway's game of life (-m ) 8 - Langton's ant (-m ) 9 - Volume bars (-m ) 10 - Evolution of color (-m ) 11 - Brightness pulse generator ``` ## Tuning the Demo Depending on your matrix type and Raspberry Pi model, some additional options may need fine-tuning: `--led-slowdown-gpio=`(0…n) Sometimes needed to throttle back the speed when using a fast Pi. Default is **1**. **For Raspberry Pi 3 use a slowdown of 1 to start (use higher values if image still flickers). For Raspberry Pi 4, use a slowdown of 4. Older Pi models might work with 0, try it.** `--led-rgb-sequence=`(RGB order) Some LED matrices may have their red, green and blue LEDs wired up in a different order…for example, if you need to swap the green and blue channels, use `--led-rgb-sequence=RBG`. Default is `RGB`. `--led-pwm-bits=`(1…11) For long matrix chains you’ll probably need to use fewer PWM bits, sacrificing some color fidelity to improve refresh speed. Default is `11`. ### The demos kinda run, but I’m seeing weird rectangles and glitches. If your Pi is overclocked, or if you’re using a Raspberry Pi 2 or Pi 4, you may need to dial back the matrix control speed slightly. This can be done with the `--led-slowdown-gpio=2` setting. Pi 4 may require larger values, depending on the matrix… **experiment!** Conversely, early Raspberry Pis (Model A, B and similar) might get an improved image by speeding up the matrix code with a value of `0` here. # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Python Usage Info: If you manually installed things, this was likely already taken care of. The installer script builds the Python bindings, but does not install them. We want to install things into a [Python virtual environment](https://learn.adafruit.com/python-virtual-environment-usage-on-raspberry-pi/overview). So the first step is to create the venv and activate it. We'll call the venv `rgbmatrix` and locate it in the pi user's home folder: ```terminal cd python3 -m venv rgbmatrix source rgbmatrix/bin/activate ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/905/medium800/led_matrices_Screenshot_from_2025-06-19_11-19-24.png?1750357174 ) Next, cd back into the directory the repo was cloned into and run make with the install-python target: ```terminal cd rpi-rgb-led-matrix/ make install-python ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/906/medium800/led_matrices_Screenshot_from_2025-06-19_11-21-21.png?1750357292 ) That should install the Python support into the venv. There are some Python examples found in the `bindings/python/samples` subfolder that can be used to test the setup. The examples must be run with `sudo`, which can be tricky when used within a venv. [The Python virtual environment guide has more information on how to deal with this](https://learn.adafruit.com/python-virtual-environment-usage-on-raspberry-pi/usage-with-sudo).  Here is an example: ```terminal cd bindings/python/samples/ sudo -E env PATH=$PATH python3 simple-square.py --led-rows=32 --led-cols=32 --led-gpio-mapping=adafruit-hat ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/910/medium800/led_matrices_Screenshot_from_2025-06-19_11-48-56.png?1750359164 ) That should result in output on the RGB matrix that looks like this: ![](https://cdn-learn.adafruit.com/assets/assets/000/137/911/medium800/led_matrices_python_example.png?1750359219 ) Parameters can be set via the command line. Change the following parameters as needed for your setup: - `--led-row=` set this to the number of LEDs in each matrix row (default=32) - `--led-cols=` set this to the number of LEDs in each matrix column (default=32) - `--led-gpio-mapping=` set this to `adafruit-hat` or `adafruit-hat-pwm` (default=regular) ## Another Basic Example The examples in the library repo have a sort of object-orientated design which may make things look overly complicated. Additionally, there is a lot of code dealing with parsing the command line options. All of the command line parameters can be configured directly in code. Here is another example to show more simply how the RGB matrix can be used in Python: ```python import time from random import randrange from rgbmatrix import RGBMatrix, RGBMatrixOptions options = RGBMatrixOptions() options.hardware_mapping = 'adafruit-hat' options.rows = 32 options.cols = 32 matrix = RGBMatrix(options = options) while True: matrix.Clear() for _ in range(1000): r = randrange(256) g = randrange(256) b = randrange(256) x = randrange(32) y = randrange(32) matrix.SetPixel(x, y, r, g, b) time.sleep(0.01) ``` ![](https://cdn-learn.adafruit.com/assets/assets/000/137/913/medium800/led_matrices_python_example2.png?1750442419 ) The general idea is to create an instance of the `RGBMatrixOptions` class and then set things as desired. Then create an instance of the `RGBMatrix` class and pass in the options. The only documentation other than the examples is the source code itself, as linked from the [repo readme](https://github.com/hzeller/rpi-rgb-led-matrix/tree/master/bindings/python#api). Here is a terse summary of the available functions and properties. The `RGBMatrixOptions` class has the following properties: ```terminal brightness chain_length cols daemon disable_hardware_pulsing drop_priv_group drop_priv_user drop_privileges gpio_slowdown hardware_mapping inverse_colors led_rgb_sequence limit_refresh_rate_hz multiplexing panel_type parallel pixel_mapper_config pwm_bits pwm_dither_bits pwm_lsb_nanoseconds row_address_type rows scan_mode show_refresh_rate ``` The `RGBMatrix` class has the following functions and properties: ```terminal Clear() CreateFrameCanvas() Fill() SetImage() SetPixel() SetPixelsPillow() SwapOnVSync() brightness height luminanceCorrect pwmBits width ``` # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Raspberry Pi 5 We recommend you use the latest Raspberry Pi OS flashed onto one of the [official Raspberry Pi SDCards](https://www.adafruit.com/product/6010). The [Raspberry Pi Imager](https://www.raspberrypi.com/software/) app makes it easy to prepare your SD Card.  - Click **Choose Device** then select the **Raspberry Pi 5**. - Click **Choose OS** then select **Raspberry Pi OS (64-bit)**. - Click **Choose Storage** then select your SDCard adapter. The name will depend on your device and it may differ from the screenshot. Once all 3 values are selected you should see them filled in to the appropriate areas of the main screen. ![led_matrices_imager_choose_device.png](https://cdn-learn.adafruit.com/assets/assets/000/134/971/medium640/led_matrices_imager_choose_device.png?1738622651) ![led_matrices_imager_choose_os.png](https://cdn-learn.adafruit.com/assets/assets/000/134/972/medium640/led_matrices_imager_choose_os.png?1738622671) ![led_matrices_imager_all_set.png](https://cdn-learn.adafruit.com/assets/assets/000/134/974/medium640/led_matrices_imager_all_set.png?1738622923) When everything has been set, click the **Next** button. You'll be asked if you'd like to apply OS customization settings. This step is optional, it allows you to put in username, WiFi credentials, and SSH public key which will get baked in to the image that is flashed to the SD Card. Enter your details and click **Yes** if you'd like to do it, otherwise click **No**. Next you'll be warned that the storage device you've select is going to be erased. Make certain it's the drive you're intending to flash and then click **Yes** to start the writing process. A pop-up will be shown once the writing has completed successfully. ![led_matrices_imager_os_customization.png](https://cdn-learn.adafruit.com/assets/assets/000/134/975/medium640/led_matrices_imager_os_customization.png?1738623398) ![led_matrices_imager_warning_erase.png](https://cdn-learn.adafruit.com/assets/assets/000/134/976/medium640/led_matrices_imager_warning_erase.png?1738623431) ![led_matrices_imager_write_success.png](https://cdn-learn.adafruit.com/assets/assets/000/134/977/medium640/led_matrices_imager_write_success.png?1738623527) ## Boot & Update If you did enter your network credentials and SSH key to the OS customization step, and you can use nmap or some other tool to locate the Pi 5 on the network and then you can do this step entirely "headless". If not you can temporarily plug in an HDMI display and USB keyboard to do it. Plug in the Pi 5, let it boot up, then update the software on it using the following commands. `sudo rpi-update` is needed especially for older Pi 5 boards. ```auto sudo rpi-update sudo apt update sudo apt upgrade sudo apt-get install python3-pip sudo reboot ``` ## Create a Virtual Environment The best practice for installing Python libraries is to use virtual environments to keep things isolated and minimize conflicts between different versions of libraries that might be required for different projects or purposes. You can name your virtual environment anything, but it's best to use something you'll remember and associate with the project your working on. I use the name `blinka_venv` for the environment containing Adafruit Blinka and all associated libraries on my Pi's. It's easy to create one with the following command. ```auto python -m venv ~/venvs/blinka_venv ``` For more info about virtual environments see [this guide.](https://learn.adafruit.com/python-virtual-environment-usage-on-raspberry-pi/overview) ## Install Requirements Next you need to activate the new virtual environment and then install the required libraries within it. ```auto source ~/venvs/blinka_venv/bin/activate pip install adafruit-blinka pip install pillow pip install numpy pip install click pip install Adafruit-Blinka-Raspberry-Pi5-Piomatter ``` ## Add PIO Subsystem Rule Configuration By default one requires root privilege to access the PIO hardware peripherals. We'll setup a rule that makes it so that the standard user can do it. We need to edit the file `/etc/udev/rules.d/99-com.rules`. ```auto sudo nano /etc/udev/rules.d/99-com.rules ``` Add a new empty line or two at the top of the file by pressing enter. Then add this to one of the empty lines. ```auto SUBSYSTEM=="*-pio", GROUP="gpio", MODE="0660" ``` To save the file press **Ctrl-S** on the keyboard. Then press **Ctrl-X** to exit. After you've done this, reboot the Pi with `sudo reboot` ## Accessing Console At present time, the python scripts that drive the matrices work best when run from the console context rather than the desktop UI context. There are a few ways you can achieve this, and depending on whether your Pi is dedicated to this usage or not you may want to set it up to boot directly to the console. ### Temporary If you don't want to make any config changes then you can simply press **Ctrl-Alt-F1** on a keyboard connected to the Pi to change from the desktop context to the console. The HDMI screen will go from showing the desktop to just the basic terminal prompt. At this prompt you can activate your virtual environment as shown above, and then run Python scripts that draw to the matrix. To go back to the desktop context you can press **Ctrl-Alt-F7**. ### SSH If you access the Pi over SSH then it already counts as the console so you can activate your virtual environment and run the matrix scripts with nothing further needed. ### Auto Boot to Console If you intend to keep using the same Pi for RGB Matrix projects, and you typically use a keyboard and HDMI screen to interact with the Pi directly, rather than SSH, then it may be convenient to configure your Pi to automatically boot directly to the console rather than the desktop. To enter the config utility run this command. ```auto sudo raspi-config ``` - Ensure  **System Options** is highlighted and press enter. - Arrow down to highlight **Boot / Auto Login** and press enter. - Highlight either **B1 Console** , or **B2 Console Autologin** and press enter. - After the setting is applied you'll be taken back to the main raspi-config screen - Arrow right until **Finish** is highlighted and press enter. - When prompted to reboot now highlight **Yes** and press enter. When the Pi boots up you'll be ready to activate your virtual environment and run the python scripts that interact with the RGB Matrix. ![led_matrices_raspi_config_main.png](https://cdn-learn.adafruit.com/assets/assets/000/135/005/medium640/led_matrices_raspi_config_main.png?1738683396) ![led_matrices_raspi_config_boot.png](https://cdn-learn.adafruit.com/assets/assets/000/135/006/medium640/led_matrices_raspi_config_boot.png?1738683413) ![led_matrices_raspi_config_auto_console.png](https://cdn-learn.adafruit.com/assets/assets/000/135/007/medium640/led_matrices_raspi_config_auto_console.png?1738683437) # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Initialization Config Initializing matrix panels to display things onto requires 3 main steps:  - Create a Geometry object to define the size and shape of the panel(s) - Create a framebuffer to hold display data - Create the PioMatter instance. ## Geometry The `Geometry` object defines the size and shape of the panel(s) that will serve as the display. There 6 arguments that can be passed to configure it. - `width` - The total width of the panel(s) in pixels. - `height` - The total height of the panel(s) in pixels. - `n_addr_lines` - The number of connected address lines. The number of pixels in the shift register is automatically computed from these values. Many panels use `4` as a standard. The [64x64 panels](https://www.adafruit.com/product/5362) that we stock use `5` address lines. Set this value according to which panels you're using. Note that using 5 addr lines also requires soldering a jumper as described on [this guide page](https://learn.adafruit.com/adafruit-rgb-matrix-bonnet-for-raspberry-pi/driving-matrices#step-2982866). - `serpentine` - Controls the arrangement of multiple panels when they are stacked in rows. If it is `True`, then each row goes in the opposite direction of the previous row. Default is `True`. - `rotation` - controls the orientation of the panel(s). Must be one of the `Orientation` constants. Default is `Orientation.Normal`. Over valid values are `Orientation.R180`, `Orientation.CW`, and `Orientation.CCW` - `n_planes` - Controls the color depth of the panel. This is separate from the framebuffer layout. Decreasing `n_planes` can increase FPS at the cost of reduced color fidelity. The default, `10`, is the maximum value. - `n_temporal_planes` - Controls the temporal dithering. Valid values are `0`, `2`, and `4`. Cannot be higher than `n_planes`. The default is `0`. Using larger values can increase the framerate in some cases experiment with your panels and application. - `map` - A pixel/lanes mapping list. For Active3 configurations use `simple_multilane_mapper(width, height, n_addr_lines, n_lanes)`. For single matrix bonnet/HAT this can be omitted. ## Framebuffer Next you need a `framebuffer`, this is a numpy array that will contain pixel data in the appropriate colorspace. When refreshed the matrix will show the data that is in this framebuffer on the display. Depending on what you're displaying it can be created in a few different ways. ```auto # For displaying an image from PIL, canvas is the PIL.Image instance framebuffer = np.asarray(canvas) + 0 # For displaying arbitrary data, start with zeros framebuffer = np.zeros(shape=(geometry.height, geometry.width, 3), dtype=np.uint8) ``` ## PioMatter Now the `PioMatter` instance can be initialized. Aside from the Geometry, and Framebuffer created above, it also accepts arguments for `colorspace` and `pinout`. - `colorspace` - Controls the colorspace that will be used for data to be displayed. It must be one of the `Colorspace` constants. Which to use depends on what data  your displaying and how it is processed before copying into the framebuffer. Many of the examples use `Colorspace.RGB888Packed`. Other valid values are `Colorspace.RGB565` and `Colorspace.RGB888` - `pinout` - Defines which pins the panels are wired to. Different pinouts can support different hardware breakouts and panels with different color order. The value must be one of the `Pinout` constants `Pinout.AdafruitMatrixBonnet`, `Pinout.AdafruitMatrixBonnetBGR`, `Pinout.AdafruitMatrixHat`, or `Pinout.AdafruitMatrixHatBGR`. For the active3/Triple Matrix Bonnet use `Pinout.Active3` or `Pinout.Active3BGR` - `framebuffer` - A `numpy.array` buffer as noted above. - `geometry` - A `Geometry` instance as noted above. ## Example Initialization Code Single matrix Bonnet/HAT: ```python geometry = piomatter.Geometry(width=64, height=32, n_addr_lines=4, rotation=piomatter.Orientation.Normal) matrix_framebuffer = np.zeros(shape=(geometry.height, geometry.width, 3), dtype=np.uint8) matrix = piomatter.PioMatter(colorspace=piomatter.Colorspace.RGB888Packed, pinout=piomatter.Pinout.AdafruitMatrixBonnet, framebuffer=matrix_framebuffer, geometry=geometry) ``` Triple Matrix Bonnet: ```auto pixelmap = simple_multilane_mapper(width, height, n_addr_lines, n_lanes) geometry = piomatter.Geometry(width=width, height=height, n_addr_lines=n_addr_lines, n_planes=10, n_temporal_planes=4, map=pixelmap, n_lanes=n_lanes) framebuffer = np.asarray(canvas) + 0 # Make a mutable copy matrix = piomatter.PioMatter(colorspace=piomatter.Colorspace.RGB888Packed, pinout=piomatter.Pinout.Active3, framebuffer=framebuffer, geometry=geometry) ``` # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Basic Test ![Adafruit Trip Matrix Bonnet running the active3 simpletest script](https://cdn-learn.adafruit.com/assets/assets/000/138/421/medium800/led_matrices_triplematrix_simpletest.png?1752591669 ) Once your [Pi 5 is all set up](https://learn.adafruit.com/adafruit-triple-led-matrix-bonnet-for-raspberry-pi-with-hub75/raspberry-pi-5-setup) and you've got the [RGB Matrix panels all wired](https://learn.adafruit.com/adafruit-triple-led-matrix-bonnet-for-raspberry-pi-with-hub75/wiring) you're ready to test it out! As always, you need to activate the virtual environment before running the example. If you haven't already then activate it like this. ```auto source ~/venvs/blinka_venv/bin/activate ``` Next you can run the **triple\_matrix\_active3\_simpletest.py** script embedded below. ```auto python triple_matrix_active3_simpletest.py ``` https://github.com/adafruit/Adafruit_Blinka_Raspberry_Pi5_Piomatter/blob/main/examples/triple_matrix_active3_simpletest.py # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## HELP! ### My display has dim red LEDs or has odd output Check that you have plugged in a good 5V 10A+ power supply into the matrices. **The Raspberry Pi's 5V power supply cannot power a matrix, you need a separate high current supply as well!** ![Matrix panels displaying very dim, and mostly only red colors, indicating that the power current is insufficient for driving the panels.](https://cdn-learn.adafruit.com/assets/assets/000/138/325/medium800/led_matrices_lowpower.png?1752156657 ) ### There are gaps and/or overlayed pixels shown on the panels This can be caused by the Adafruit bonnet address E switch being in the wrong position for the specific panels that you are using. Power down the Pi and displays, then carefully slide the switch into the other position and then reapply power and try running the code again. ![Matrix panels displaying test graphics with clear gaps in the middle of shapes that are supposed to be whole.](https://cdn-learn.adafruit.com/assets/assets/000/138/326/medium800/led_matrices_switch_wrong_example.png?1752156790 ) # Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75 ## Downloads ## Files - [Fritzing object in the Adafruit Fritzing Library](https://github.com/adafruit/Fritzing-Library/blob/master/parts/Adafruit%20Triple%20LED%20Matrix%20Bonnet.fzpz) - [EagleCAD PCB files on GitHub](https://github.com/adafruit/Adafruit-Triple-LED-Matrix-Bonnet-PCB) - [3D Model](https://github.com/adafruit/Adafruit_CAD_Parts/tree/main/6358%20Triple%20LED%20Matrix%20Bonnet) ## Schematic and Fab Print ![schematic for the bonnet](https://cdn-learn.adafruit.com/assets/assets/000/138/305/medium800/led_matrices_schem.png?1752105286 ) ![fab print for pcb](https://cdn-learn.adafruit.com/assets/assets/000/138/306/medium800/led_matrices_fab.png?1752105306 dimensions are in inches) ## Primary Products ### Adafruit Triple LED Matrix Bonnet for Raspberry Pi - For HUB75 [Adafruit Triple LED Matrix Bonnet for Raspberry Pi - For HUB75](https://www.adafruit.com/product/6358) You can now create large, dazzling LED matrix displays with your Raspberry Pi with the **Adafruit Triple Matrix Bonnet for Raspberry Pi.** This boards plugs into your Raspberry Pi with 2x20 header, and makes it super easy to control... In Stock [Buy Now](https://www.adafruit.com/product/6358) [Related Guides to the Product](https://learn.adafruit.com/products/6358/guides) ## Featured Products ### 64x64 RGB LED Matrix - 2.5mm Pitch [64x64 RGB LED Matrix - 2.5mm Pitch](https://www.adafruit.com/product/3649) Winter time can be rough in the city. The sky is gray. The weather is unpredictable. So slough off those seasonal blues with some Times Square razzle dazzle from this sweet, ultra-high-density **64x64 RGB LED Matrix**. These panels are typically used to make video... In Stock [Buy Now](https://www.adafruit.com/product/3649) [Related Guides to the Product](https://learn.adafruit.com/products/3649/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) ### 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) ### 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) ### 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) ### GPIO Stacking Header for Pi A+/B+/Pi 2/Pi 3/Pi 4/Pi 5 [GPIO Stacking Header for Pi A+/B+/Pi 2/Pi 3/Pi 4/Pi 5](https://www.adafruit.com/product/2223) Connect your own PCB to a Raspberry Pi B+ and stack on top with this normal-height female header with extra long pins.  The female header part is about 8.5mm tall, good for small HATs that do not to clear the USB/Ethernet jacks. This header has extra long 10mm pins, compared with our In Stock [Buy Now](https://www.adafruit.com/product/2223) [Related Guides to the Product](https://learn.adafruit.com/products/2223/guides) ### 2x20 Socket Riser Header for Raspberry Pi HATs and Bonnets [2x20 Socket Riser Header for Raspberry Pi HATs and Bonnets](https://www.adafruit.com/product/4079) Give yourself a lift with this 2x20 female socket header that has _slightly longer than usual pins_. You can plug this into your Raspberry Pi GPIO port and then plug a HAT or Bonnet or Phat on top. Especially useful for Bonnets that have slim headers on the bottom, but you want... In Stock [Buy Now](https://www.adafruit.com/product/4079) [Related Guides to the Product](https://learn.adafruit.com/products/4079/guides) ### Power Distribution Bus - 7 x 6mm diameter solid brass [Power Distribution Bus - 7 x 6mm diameter solid brass](https://www.adafruit.com/product/737) Imagine terminal blocks that are cut out of one solid piece of brass, designed to distribute power. Well, that's what we have here! These machined bus bars are for when you want to distribute power through a project, we think they are ideal for robots and LED pixel grids where you have... Out of Stock [Buy Now](https://www.adafruit.com/product/737) [Related Guides to the Product](https://learn.adafruit.com/products/737/guides) ## Related Guides - [Cardboard Window Skull With Animated LED Eyes](https://learn.adafruit.com/cardboard-window-skull-animated-led-eyes.md) - [Expressive Pixels for Adafruit Matrix Portal](https://learn.adafruit.com/expressive-pixels-for-matrix-portal.md) - [Matrix Portal RGB Display Handbag](https://learn.adafruit.com/matrix-portal-rgb-display-handbag.md) - [Animated GIF Player for Matrix Portal](https://learn.adafruit.com/animated-gif-player-for-matrix-portal.md) - [Weather Display Matrix](https://learn.adafruit.com/weather-display-matrix.md) - [RGB LED Matrix Basics](https://learn.adafruit.com/32x16-32x32-rgb-led-matrix.md) - [Matrix Portal Stained Glass with WLED](https://learn.adafruit.com/matrix-portal-stained-glass-with-wled.md) - [Purple Air AQI Display](https://learn.adafruit.com/purple-air-aqi-display.md) - [Image Correction for RGB LED Matrices](https://learn.adafruit.com/image-correction-for-rgb-led-matrices.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) - [Tombstone Matrix Portal](https://learn.adafruit.com/tombstone-matrix-portal.md) - [Bluetooth-Controlled Matrix LED Sign using Bluefruit Connect](https://learn.adafruit.com/bluetooth-controlled-matrix-led-sign-using-bluefruit-connect.md) - [Matrix Portal Sand Handles](https://learn.adafruit.com/matrix-portal-sand.md) - [Network Connected RGB Matrix Clock](https://learn.adafruit.com/network-connected-metro-rgb-matrix-clock.md) - [RGB LED Matrices with CircuitPython](https://learn.adafruit.com/rgb-led-matrices-matrix-panels-with-circuitpython.md)