# Matrix Portal Flow Visualizer ## Overview ![](https://cdn-learn.adafruit.com/assets/assets/000/097/098/medium800thumb/led_matrices_fish_banner.jpg?1605632871) ![](https://cdn-learn.adafruit.com/assets/assets/000/096/873/medium800/led_matrices_davinci_banner.jpg?1604772843) In the field of fluid dynamics, the [Navier-Stokes equations](https://en.wikipedia.org/wiki/Navier%E2%80%93Stokes_equations) are considered to be the governing equations for fluid flow. They are a mess to deal with directly. However, by ignoring the effects of [viscosity](https://en.wikipedia.org/wiki/Viscosity) and density changes ([compressibility](https://en.wikipedia.org/wiki/Compressibility)), the equations reduce down to a much more tractable form known as [Laplace's equation](https://en.wikipedia.org/wiki/Laplace%27s_equation), which has applications in more than just fluid dynamics. When used in fluid dynamics, the resulting flow is referred to as [potential flow](https://en.wikipedia.org/wiki/Potential_flow). Directly trying to solve the Navier-Stokes equations is the realm of [high end computing](https://en.wikipedia.org/wiki/Computational_fluid_dynamics) and [PhD level research](https://en.wikipedia.org/wiki/Turbulence_modeling). By contrast, potential flow problems are commonly assigned as undergraduate homework. Only a minimum amount of computing power is needed. There's even enough power in a little microcontroller, like the ones found on a Matrix Portal, Feathers, and other microcontroller boards. In this guide, we'll use a [Matrix Portal](https://www.adafruit.com/product/4745) to create a flow field visualizer based on potential flow. We'll cover a couple of different approaches. The goal here isn't to teach aerodynamics though. We'll provide some details, but this is more of a just-for-fun project that can create some fun and interesting animations. ![](https://cdn-learn.adafruit.com/assets/assets/000/097/097/medium800thumb/led_matrices_banner5.jpg?1605632722) ## Hardware If you have an [AdaBox 016](https://learn.adafruit.com/adabox016), then you have everything you need for this project. Otherwise, the parts are available a la carte: ### Adafruit Matrix Portal - CircuitPython Powered Internet Display [Adafruit Matrix Portal - CircuitPython Powered Internet Display](https://www.adafruit.com/product/4745) Folks love our [wide selection of RGB matrices](https://www.adafruit.com/category/327) and accessories, for making custom colorful LED displays... and our RGB Matrix Shields and FeatherWings can be quickly soldered together to make the wiring much easier. But what if we made it... In Stock [Buy Now](https://www.adafruit.com/product/4745) [Related Guides to the Product](https://learn.adafruit.com/products/4745/guides) ![Video of a person rotating an LED matrix panel with animation resembling falling colored sand.](https://cdn-shop.adafruit.com/product-videos/640x480/4745-05.jpg) ### 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) ![Two white hands hold out an assembled and powered on 64x32 RGB LED Matrix Panel - 4mm pitch. The matrix displays "Adafruit Industries LED MATRIX! 32x64 *RGB*"](https://cdn-shop.adafruit.com/640x480/2278-00.jpg) ### Black LED Diffusion Acrylic Panel - 10.2" x 5.1" [Black LED Diffusion Acrylic Panel - 10.2" x 5.1"](https://www.adafruit.com/product/4749)  nice whoppin' rectangular slab of some lovely black acrylic to add some extra diffusion to your LED Matrix project. This material is 2.6mm (0.1") thick and is made of special cast acrylic that makes it perfect for glowy projects, especially matrices or NeoPixels. Unlike... In Stock [Buy Now](https://www.adafruit.com/product/4749) [Related Guides to the Product](https://learn.adafruit.com/products/4749/guides) ![LED RGB matrix 10.2" x 5.1" with "Adafruit Industries LED Matrix" text showing, and LED acrylic slowly covering to make it nicely diffused](https://cdn-shop.adafruit.com/product-videos/640x480/4749-02.jpg) Or as a kit: ### Adafruit Matrix Portal Starter Kit - ADABOX 016 Essentials [Adafruit Matrix Portal Starter Kit - ADABOX 016 Essentials](https://www.adafruit.com/product/4812) If you missed out on [AdaBox016](https://www.youtube.com/watch?v=Yr3F8EBAVBU), it's not too late for you to pick up the parts necessary to build many of the projects! It doesn't come with tissue paper or the nifty extras, but it does have all the electronic goodies you... In Stock [Buy Now](https://www.adafruit.com/product/4812) [Related Guides to the Product](https://learn.adafruit.com/products/4812/guides) ![Top view of kit contents for MatrixPortal Starter kit.](https://cdn-shop.adafruit.com/640x480/4812-00.jpg) # Matrix Portal Flow Visualizer ## Flow Singularities ![](https://cdn-learn.adafruit.com/assets/assets/000/096/785/medium800/led_matrices_pot_flow_banner.jpg?1604531779) One way to use potential flow is to create a set of basic flow elements. Each of these basic flow elements, often called "singularities", is a specific solution to the governing Laplace's equation. The idea is to use them as building blocks to create and describe various flow fields. This idea works because if A and B are each a solution to Laplace's equation, then so is A+B. And you can keep adding as many as you want, A+B+C, etc. So they are sort of like aerodynamic legos. Click them together to create different flow fields. ## Coordinate System We will work in the native display coordinate system as shown below. This is a little different than the typical coordinate system used in engineering. But these are just conventions. As long as the coordinate system being used is known and accounted for, the results are the same. ![](https://cdn-learn.adafruit.com/assets/assets/000/096/764/medium800/led_matrices_coord_sys.jpg?1604522594) We will also stick with just a cartesian notation for everything, even though polar coordinates are cleaner for some of the singularities. Cartesian coordinates will be used in the code as well. So by sticking with cartesian notation, it also makes it easier to understand the code (hopefully). ## Singularities Each singularity has a location **(SX,  SY)** and a strength **S**. The velocity **(vx, vy)** induced at some point **(x, y)** is then described by functions **fx(), fy()** specific to the singularity type. - **(SX, SY)** = singularity location in global coordinate system (i.e., on the matrix) - **(x, y)** = point relative to singularity location - **vx, vy** = velocity components induced at point **(x, y)** by singularity ![led_matrices_singularity_generic.png](https://cdn-learn.adafruit.com/assets/assets/000/096/776/medium640/led_matrices_singularity_generic.png?1604525697) So let's define our basic flow elements. There are four of them. **Freestream** flow is just flow everywhere moving in the same direction. It's unique in that it doesn't have a location. Instead, you just define the two components **sx** and **sy**. For "straight" flow, left to right, you'd set **sy=0** , for example. ![led_matrices_singularity_freestream.png](https://cdn-learn.adafruit.com/assets/assets/000/096/779/medium640/led_matrices_singularity_freestream.png?1604526269) A **source** shoots out in all directions from its origin location. A **sink** is just a source with negative strength, and then all the lines go in instead of out. - **S \> 0 = source** - **S \< 0 = sink** ![led_matrices_singularity_source.png](https://cdn-learn.adafruit.com/assets/assets/000/096/780/medium640/led_matrices_singularity_source.png?1604526865) A **vortex** is like a whirlpool. Flow spins in a circle around the origin location. The sign of the strength sets the direction of rotation. ![led_matrices_singularity_vortex.png](https://cdn-learn.adafruit.com/assets/assets/000/096/782/medium640/led_matrices_singularity_vortex.png?1604527443) A **doublet** is a source/sink pair brought together so they sit on top of each other. It's a bit of an oddball, but has its use. ![led_matrices_singularity_doublet.png](https://cdn-learn.adafruit.com/assets/assets/000/096/783/medium640/led_matrices_singularity_doublet.png?1604528328) And that's our set of aerodynamic legos. Now let's play with them. # Matrix Portal Flow Visualizer ## Install CircuitPython [CircuitPython](https://github.com/adafruit/circuitpython) is a derivative of [MicroPython](https://micropython.org) designed to simplify experimentation and education on low-cost microcontrollers. It makes it easier than ever to get prototyping by requiring no upfront desktop software downloads. Simply copy and edit files on the **CIRCUITPY** drive to iterate. ## Set up CircuitPython Quick Start! Follow this quick step-by-step for super-fast Python power :) [Download the latest version of CircuitPython for this board via circuitpython.org](https://circuitpython.org/board/matrixportal_m4/) ## Further Information For more detailed info on installing CircuitPython, check out [Installing CircuitPython](https://learn.adafruit.com/welcome-to-circuitpython/installing-circuitpython). **Click the link above and download the latest UF2 file.** Download and save it to your desktop (or wherever is handy). ![led_matrices_Save_to_Desktop.png](https://cdn-learn.adafruit.com/assets/assets/000/095/075/medium640/led_matrices_Save_to_Desktop.png?1601050695) Plug your MatrixPortal M4 into your computer using a known-good USB cable. **A lot of people end up using charge-only USB cables and it is very frustrating! So make sure you have a USB cable you know is good for data sync.** Double-click the **Reset** button (indicated by the green arrow) on your board, and you will see the NeoPixel RGB LED (indicated by the magenta arrow) turn green. If it turns red, check the USB cable, try another USB port, etc. If double-clicking doesn't work the first time, try again. Sometimes it can take a few tries to get the rhythm right! ![led_matrices_matrixportal_install_cp.jpg](https://cdn-learn.adafruit.com/assets/assets/000/125/447/medium640/led_matrices_matrixportal_install_cp.jpg?1697644568) You will see a new disk drive appear called **MATRIXBOOT**.   Drag the **adafruit\_circuitpython\_etc.uf2** file to **MATRIXBOOT****.** ![led_matrices_MATRIXBOOT.png](https://cdn-learn.adafruit.com/assets/assets/000/125/448/medium640/led_matrices_MATRIXBOOT.png?1697644692) ![led_matrices_Drag_to_Drive.png](https://cdn-learn.adafruit.com/assets/assets/000/125/449/medium640/led_matrices_Drag_to_Drive.png?1697644703) The LED will flash. Then, the **MATRIXBOOT**  drive will disappear and a new disk drive called **CIRCUITPY** will appear. That's it, you're done! :) ![led_matrices_circuitpy.png](https://cdn-learn.adafruit.com/assets/assets/000/125/450/medium640/led_matrices_circuitpy.png?1697645066) # Matrix Portal Flow Visualizer ## Singularity Visualizer Here's the code for our singularity viewer. It lets you define the type, location, and strength of one or more singularities. To see the results, you specify the starting location for one or more [streamlines](https://en.wikipedia.org/wiki/Streamlines,_streaklines,_and_pathlines).  Then the program computes the resulting streamlines and animates them. ![](https://cdn-learn.adafruit.com/assets/assets/000/096/874/medium800/led_matrices_Screenshot_from_2020-11-07_16-32-57.png?1604795595) ## Installing Project Code To use with CircuitPython, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **Matrix\_Portal\_Flow\_Viewer/flow/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive. Your **CIRCUITPY** drive should now look similar to the following image: ![CIRCUITPY](https://adafruit.github.io/Adafruit_Learning_System_Guides/Matrix_Portal_Flow_Viewer_flow.png ) https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Matrix_Portal/Matrix_Portal_Flow_Viewer/flow/code.py ## How to Use Look at the top of the code for the section commented as `User Config`. These are the lines you can change to configure the resulting flow field displayed. The main ones are **SINGULARITIES** and **SEEDS**. - **SINGULARITIES** - Add a tuple containing the type, location, and strength for each singularity you want. You generally always want a **freestream** element, otherwise flow won't "flow" through the display. The available types are: - **freestream** - **source** (remember, a **sink** is just a source with a negative strength) - **vortex** - **doublet** - **SEEDS** - These define the streamlines. Add a tuple of **(x, y)** starting location for each streamline you want. The code is setup to use a 64x32 matrix size. If you have a different size, change **MATRIX\_WIDTH** and **MATRIX\_HEIGHT**. The rest affect the general aesthetics of the flow animation: - **BACK\_COLOR** - Background fill color. - **SING\_COLOR** - Each singularity is shown as a single pixel of this color. - **HEAD\_COLOR** - The pixel color for the leading pixel in a streamline trace. - **TAIL\_COLOR** - The pixel color for the tail of the streamline trace. - **TAIL\_LENGTH** - How many pixels long the streamline trace will be. - **DELAY** - How fast the animation runs. Lower numbers are faster. ## Singularity Strength So what are good values for the singularity strengths? 1? 50000? We aren't working with any actual units. So you can't set the freestream flow to be 55 mile per hour, for example. You can set any values you want, but you may find the results don't appear or animate well on the actual matrix if you set them too large. **In general, keep things in the single digit range**. We'll provide some examples next, so also notice the strength values used in those. # Matrix Portal Flow Visualizer ## Example Flows Here are some basic examples that can help get you started. For each one we give you the lines of code to use at the top of the code to define the singularities and the seeds for the streamlines. That way you can just copy-paste them in. ## Flow Over an Ovoid These all called Rankine bodies or Rankine ovals after [Macquorn Rankine](https://en.wikipedia.org/wiki/Macquorn_Rankine). The flow is comprised of **freestream** plus a **source** and **sink** pair. ```python #--| User Config |----------------------------------------- SINGULARITIES = ( # type location strength ('freestream', None, (1, 0)), ('source', (26, 16), 3), ('source', (38, 16), -3), ) SEEDS = ( # (x, y) starting location (0, 0), (0, 3), (0, 6), (0, 9), (0, 12), (0, 15), (0, 17), (0, 20), (0, 23), (0, 26), (0, 29), ) MATRIX_WIDTH = 64 MATRIX_HEIGHT = 32 BACK_COLOR = 0x000000 # background fill SING_COLOR = 0xADAF00 # singularities HEAD_COLOR = 0x00FFFF # leading particles TAIL_COLOR = 0x000A0A # trailing particles TAIL_LENGTH = 10 # length in pixels DELAY = 0.01 # smaller = faster #---------------------------------------------------------- ``` The result should look like this: ![](https://cdn-learn.adafruit.com/assets/assets/000/096/863/medium800thumb/led_matrices_oval_banner.jpg?1604701372) ## Lifting Flow Over a Cylinder This is called a [cylinder](https://en.wikipedia.org/wiki/Potential_flow_around_a_circular_cylinder) instead of a sphere since the flow is two dimensional. We use a **doublet** to generate the main cylinder flow. To simulate lift we use a **vortex**. The two are located at the same location. And of course we still need our good 'ole friend the **freestream**. ```python #--| User Config |----------------------------------------- SINGULARITIES = ( # type location strength ('freestream', None, (1, 0)), ('doublet', (32, 16), 3), ('vortex', (32, 16), 4), ) SEEDS = ( # (x, y) starting location (0, 0), (0, 3), (0, 6), (0, 9), (0, 12), (0, 15), (0, 17), (0, 20), (0, 23), (0, 26), (0, 29), ) MATRIX_WIDTH = 64 MATRIX_HEIGHT = 32 BACK_COLOR = 0x000000 # background fill SING_COLOR = 0xADAF00 # singularities HEAD_COLOR = 0x00FFFF # leading particles TAIL_COLOR = 0x000A0A # trailing particles TAIL_LENGTH = 10 # length in pixels DELAY = 0.01 # smaller = faster #---------------------------------------------------------- ``` What does this one look like? Well...run it and see :) # Matrix Portal Flow Visualizer ## Flow Solver Viewer ![](https://cdn-learn.adafruit.com/assets/assets/000/096/872/medium800/led_matrices_flow_solver.jpg?1604766400) The flow singularity approach is nice and easy but is sort of backwards. You specify the singularities and the resulting flow field is then computed. More often, you have some blob and want to know the resulting flow over it. To do this, a different approach is taken. You define the shape of your blob and other flow field parameters and then Laplace's equation is solved numerically. The solution is the resulting flow field, so this is called a "flow solver". The trade off here is complexity. Not only for the underlying solution process (differential equation solver), but also for actually using the flow solver (grid generator, boundary conditions, etc.). However, we found this really neat Python based solver: [2D Potential Flow Solver](https://github.com/e-natalia/potential-flow) This is super easy to use since the setup is simply a matrix. You fill the matrix with one of the possible flow elements, and then send it to the solver. The solver outputs the resulting flow field, also as a matrix. This pairs nicely with the RGB matrix. The idea is to use the RGB matrix as a viewer for the flow solution. The solver won't actually run on the Matrix Portal\* so we'll do something like this: 1. Install the flow solver on a PC. 2. Define our blob and run the solver on the PC. 3. Output flow solution to a file. 4. Copy solution file to Matrix Portal. 5. Run viewer script on Matrix Portal. \*it probably could though, given enough time to port the code to CircuitPython. ## Install Required Software **Do this software setup on the PC you want to run the flow solver on.** You'll need the following software. Click the links to go to installation instructions. - [**Python**](https://www.python.org/) - you may already have this installed. - [**NumPy**](https://pypi.org/project/numpy/) - used by the flow solver. - [**Pillow/PIL**](https://pypi.org/project/Pillow/) - used to read BMP defining input geometry. Then we need to install the [flow solver software](https://github.com/e-natalia/potential-flow). If you are familiar with git, you can just clone the solver repo linked above. Otherwise, you can download the solver code as follows: - Go to the [repo on Github](https://github.com/e-natalia/potential-flow). - Click the green **Code** button. - Click **Download ZIP** and save the file. - Unzip the contents to a folder location on your PC. ![led_matrices_solver_download.jpg](https://cdn-learn.adafruit.com/assets/assets/000/096/805/medium640/led_matrices_solver_download.jpg?1604612031) We'll work in the folder location where you saved the solver. So remember it. ## Define Input Geometry This is done with a BMP file. It should be a black and white image the same size as the RGB matrix. **See the next section for details about creating this file.** ## Solver Script **Run this on your PC.** OK, now grab the solver script which will read in your BMP file, run the solver, and then output the results. To make things easy to run, save a copy of this file in the **same folder as flow solver** that was download above. https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Matrix_Portal/Matrix_Portal_Flow_Viewer/flow_runner.py To run the solver, use the following command: ```python python flow_runner.py geometry.bmp ``` where `geometry.bmp` is the BMP file you created to define your input geometry. You can use a different name if you want, but the BMP file should be located in the same folder location. If it runs without errors, it should say **DONE** and the results will be in a new file named `flow_solution.py`. Move on to the next section for how to view those results! ## Viewer Script **Run this on the Matrix Portal.** ## Installing Project Code To use with CircuitPython, you need to first install a few libraries, into the lib folder on your **CIRCUITPY** drive. Then you need to update **code.py** with the example script. Thankfully, we can do this in one go. In the example below, click the **Download Project Bundle** button below to download the necessary libraries and the **code.py** file in a zip file. Extract the contents of the zip file, open the directory **Matrix\_Portal\_Flow\_Viewer/flow\_viewer/** and then click on the directory that matches the version of CircuitPython you're using and copy the contents of that directory to your **CIRCUITPY** drive. Your **CIRCUITPY** drive should now look similar to the following image: ![CIRCUITPY](https://adafruit.github.io/Adafruit_Learning_System_Guides/Matrix_Portal_Flow_Viewer_flow_viewer.png ) Info: https://github.com/adafruit/Adafruit_Learning_System_Guides/blob/main/Matrix_Portal/Matrix_Portal_Flow_Viewer/flow_viewer/code.py After running the solver script on your PC, you should end up with a file named `flow_solution.py`. Copy that file to your **CIRCUITPY** folder. Then use the following script to view the results. ## Customizing The Viewer Similar to our singularity viewer, you can customize the behavior. Look for the `User Config` section near the top. The options are the same as for the singularity viewer, so see the information in that section. # Matrix Portal Flow Visualizer ## Creating Bitmaps We use a bitmap (BMP) file to define the geometry to input into the flow solver discussed in the previous section. This lets you use image editing software like Photoshop or Gimp to easily draw whatever shapes you want. Here we give some brief info on how to do this. The example here shows [Gimp](https://www.gimp.org/). Info: ## Create Blank Bitmap Create a new image ( **File -\> New...** ) and set the pixel size to match the matrix size, for example 64 x 32. Set the Image mode to indexed ( **Image -\> Mode -\> Indexed** ) and set the maximum number of palette colors to 2. Then turn on grids ( **View -\> Show Grid** ) and zoom in. You should have a nice blank canvas to start drawing your geometry. ![](https://cdn-learn.adafruit.com/assets/assets/000/096/806/medium800/led_matrices_Screenshot_from_2020-11-05_14-02-18.png?1604613757) ## Draw Geometry Use the **Toolbox** palette to select the **Pencil** tool. In the Pencil options, set the **Brush** to **Pixel** and the **Size** to **1**. You are now ready to draw your geometry one pixel at a time. ![](https://cdn-learn.adafruit.com/assets/assets/000/096/862/medium800/led_matrices_Screenshot_from_2020-11-05_14-10-51.png?1604700555) You can make more than one blob if you want. Here we just show a happy little fish. Info: ## Export Geometry When you are done and ready to save your geometry, export it as a BMP file. It's a good idea to also save it in the native Gimp (or Photoshop) format also, to make future edits easier. To export to a BMP file use **File -\> Export As...** and save it. You can then use the BMP as an input to flow solver runner script discussed in the previous section. ![](https://cdn-learn.adafruit.com/assets/assets/000/096/861/medium800thumb/led_matrices_fish_banner.jpg?1604700477) ## Examples Here are a few ready to go BMP files you can use to get started. [fish.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/866/original/fish.bmp?1604705872) [hearts.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/867/original/hearts.bmp?1604705882) [multi_element.bmp](https://cdn-learn.adafruit.com/assets/assets/000/096/868/original/multi_element.bmp?1604705889) But get creative and have fun with this. Enjoy :) ![](https://cdn-learn.adafruit.com/assets/assets/000/096/865/medium800thumb/led_matrices_hearts_banner.jpg?1604702472) ## Featured Products ### Adafruit Matrix Portal - CircuitPython Powered Internet Display [Adafruit Matrix Portal - CircuitPython Powered Internet Display](https://www.adafruit.com/product/4745) Folks love our [wide selection of RGB matrices](https://www.adafruit.com/category/327) and accessories, for making custom colorful LED displays... and our RGB Matrix Shields and FeatherWings can be quickly soldered together to make the wiring much easier. But what if we made it... In Stock [Buy Now](https://www.adafruit.com/product/4745) [Related Guides to the Product](https://learn.adafruit.com/products/4745/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) ### Black LED Diffusion Acrylic Panel - 10.2" x 5.1" [Black LED Diffusion Acrylic Panel - 10.2" x 5.1"](https://www.adafruit.com/product/4749)  nice whoppin' rectangular slab of some lovely black acrylic to add some extra diffusion to your LED Matrix project. This material is 2.6mm (0.1") thick and is made of special cast acrylic that makes it perfect for glowy projects, especially matrices or NeoPixels. Unlike... In Stock [Buy Now](https://www.adafruit.com/product/4749) [Related Guides to the Product](https://learn.adafruit.com/products/4749/guides) ### Adafruit Matrix Portal Starter Kit - ADABOX 016 Essentials [Adafruit Matrix Portal Starter Kit - ADABOX 016 Essentials](https://www.adafruit.com/product/4812) If you missed out on [AdaBox016](https://www.youtube.com/watch?v=Yr3F8EBAVBU), it's not too late for you to pick up the parts necessary to build many of the projects! It doesn't come with tissue paper or the nifty extras, but it does have all the electronic goodies you... In Stock [Buy Now](https://www.adafruit.com/product/4812) [Related Guides to the Product](https://learn.adafruit.com/products/4812/guides) ## Related Guides - [Adafruit MatrixPortal M4](https://learn.adafruit.com/adafruit-matrixportal-m4.md) - [Adafruit Triple LED Matrix Bonnet for Raspberry Pi with HUB75](https://learn.adafruit.com/adafruit-triple-led-matrix-bonnet-for-raspberry-pi-with-hub75.md) - [Custom Scrolling Quote Board Matrix Display](https://learn.adafruit.com/aio-quote-board-matrix-display.md) - [Animated GIF Player for Matrix Portal](https://learn.adafruit.com/animated-gif-player-for-matrix-portal.md) - [Matrix Portal New Guide Scroller](https://learn.adafruit.com/matrix-portal-new-guide-scroller.md) - [RGB Matrix New York Times Title Scroller](https://learn.adafruit.com/rgb-matix-nyt-text-scroller.md) - [Raspberry Pi LED Matrix Display](https://learn.adafruit.com/raspberry-pi-led-matrix-display.md) - [Stream Deck controlled RGB Message Panel using Adafruit IO](https://learn.adafruit.com/stream-deck-controlled-rgb-message-panel-using-adafruit-io.md) - [Halloween Countdown Display Matrix](https://learn.adafruit.com/halloween-countdown-display-matrix.md) - [Shake Away 2021 with MatrixPortal](https://learn.adafruit.com/matrixportal-shake-away-2020.md) - [IoT Twitter Listener Party Parrot](https://learn.adafruit.com/iot-twitter-listener-party-parrot.md) - [AdaBox 016](https://learn.adafruit.com/adabox016.md) - [LED Protest Sign](https://learn.adafruit.com/led-protest-sign.md) - [Adafruit SPA06-003 - Temperature + Pressure Sensor](https://learn.adafruit.com/adafruit-spa06-003-temperature-pressure-sensor.md) - [Using LoraWAN and The Things Network with CircuitPython](https://learn.adafruit.com/using-lorawan-and-the-things-network-with-circuitpython.md)