Close
0%
0%

MatTris Arcade

MatTris Arcade is a DIY retro game console built around a 14×20 LED matrix, It packs six classic games into one tiny console.

Similar projects worth following
0 followers
Meet MatTris Arcade, a homemade handheld console that uses a 14 × 20 RGB LED matrix as its screen.

This project started as a small Tetris console, inspired by the handheld brick games I grew up playing. After building the hardware, I wanted to see what else the same display and buttons could do, so I expanded the firmware to include Snake, Pong, Breakout, Car Dodge, and Space Invaders.

The console uses a Waveshare RP2040-Tiny, a custom PCB, rechargeable battery power, and a 3D-printed enclosure. A simple pixel-based menu lets you choose a game and difficulty using the onboard buttons.

I was born in 1998, and my first introduction to Tetris was through those small monochrome LCD handhelds that came with 50, 100, sometimes even 999 built-in games. Most of them were pretty basic, but somehow you could spend hours playing them.

A few years ago, I decided to recreate that feeling using the kind of hardware I work with now. That project became MatTris, a small Tetris machine built using a WS2812B LED matrix and a Waveshare RP2040 Tiny.

You can check out the original project here: MatTris – Tetris on an LED Matrix.

I was pretty happy with how it turned out, but after using it for a while, I started thinking about the things I could have done differently. The enclosure was one of them. Also, having only Tetris on it felt like a bit of a missed opportunity.

So I decided to rebuild the whole thing.

For the new version, I wanted to keep the same basic idea but make it feel more like a small arcade console. I designed a completely new case, made some changes to the overall build and added a few more games that work with the same LED matrix.

The electronics are still based around a WS2812B mini LED matrix and a Waveshare RP2040 Tiny. The custom PCB handles the LED matrix, buttons and power management, and the whole thing runs from a rechargeable LiPo battery.

The main challenge was actually getting different games to work on such a small display. With only a 14×20 matrix, you don't have a lot of space to work with, so I had to keep the games and controls simple while still making them fun to play.

This is basically the second version of the project, but with a lot more stuff packed into it.

So let's take a look at how I built the new MatTris Arcade

let's get started.

MATERIALS REQUIRED

The following materials were used in this project:

  • Custom PCB (Provided by HQ NextPCB)
  • RP2040 Tiny Waveshare board
  • WS2812B 2020 Package LEDs
  • 100 nF Capacitors 0603 Package
  • 10 uF Capacitor 1206 Package
  • IP5306
  • 10 uH Inductor
  • Indicator LED 0805 Package
  • USB Type-C port
  • Push Buttons 6x6 SMD
  • 2 Ohms 1206 Package
  • RP2040 Tiny Programmer
  • 3D Printed Enclosure

Hardware

The main controller for the MatTris Arcade is the Waveshare RP2040 Tiny. I kept the same controller from the previous version because the RP2040 has more than enough processing power for these small games and it is also quite compact.

The RP2040 is based on the Raspberry Pi RP2040 dual-core ARM Cortex-M0+, running at up to 133 MHz. In this project, one of its cores isn't really being pushed that hard, but having the extra processing power does make things like the LED updates, button input and game logic pretty comfortable to handle.

The RP2040 Tiny also keeps the overall PCB small, which was important here because I wanted to leave as much space as possible for the 14 × 20 LED matrix.

The controller handles the WS2812B LEDs, reads all the game buttons and runs the complete game logic. The code and all six games are stored directly on the RP2040, so no phone or external device is needed while playing.

PCB DESIGN

The PCB design process begins with preparing the schematic for the project. In our case, we had previously worked with WS2812B 2020 package LEDs. These LEDs are not the easiest to work with because of their small size, but that same compact form factor is exactly what makes them ideal for matrix-based projects.

We reused the schematic from our earlier 8×8 Tiny Matrix project as a starting point. Instead of an 8×8 layout, we expanded the design to a 14×20 matrix by adding more LEDs.

We then added another section to the schematic for the RP2040 Tiny board, which was connected to six push buttons. All buttons are connected to GND and individual GPIO pins. When a button is pressed, it pulls the corresponding GPIO pin low, and the microcontroller registers this as a button press.

We used the Waveshare's RP2040 Tiny, which is an RP2040-based SMD development board designed to be mounted directly onto...

Read more »

tetris sch.pdf

Adobe Portable Document Format - 312.56 kB - 10/20/2026 at 14:02

Preview

MatTris_MultiGame (1).zip

Zip Archive - 15.64 kB - 10/20/2026 at 14:02

Download

  • 1
    STENCIL PROCESS

    We started the circuit assembly process by applying solder paste to the PCB, but there was a slight problem. The number of components used in this project is quite large, which also means a very high number of pads. Because of this, using a solder paste dispensing syringe would be impractical. Instead, we used a custom stencil made specifically for this circuit.

    A stencil is essentially a thin metal sheet with laser-cut slots and holes that match the component pads on the PCB. Using a stencil allows solder paste to be applied evenly across all pads. In industrial settings, where circuits are mass-produced, stencils are commonly used for this purpose.

    1. We first set up a makeshift PCB and stencil holder using extra PCBs. This setup helped keep the main PCB stationary and ensured it did not move during the process.
    2. After aligning the stencil openings with the PCB component pads, we applied solder paste over the stencil and used a scraper to spread it evenly across the slots. This process deposited a thin, uniform layer of solder paste onto each component pad, preparing the board for component placement.
  • 2
    SMD COMPONENTS PLACEMENT PROCESS

    Now comes another tedious process: SMD component placement. It is tedious because of the sheer number of LEDs used in this project. In total, we used 280 LEDs along with several other SMD components, bringing the overall component count to over 300. All of these components had to be placed manually.

    1. We started by placing the 100 nF decoupling capacitors in their designated locations. For the pick-and-place process, we used ESD-safe tweezers.
    2. Next, we placed all 280 SMD RGB LEDs onto their pads, making sure each LED was oriented correctly, as incorrect orientation would prevent the LEDs from working.
    3. After the LED placement, we added the remaining SMD components, which included the SMD push buttons and all the parts related to the power management circuit.
    4. Once all components were placed, the entire board was carefully lifted and placed onto an SMD reflow hotplate. The hotplate heats the PCB from below up to the solder paste melting temperature, which is around 200°C. As a result, all the components are soldered securely to their pads.
  • 3
    TESTING SMD LEDs

    Before we move ahead with the placement of the RP2040 board on the backside of the PCB, we tested whether the LEDs were working or not. If the LEDs were not working and the RP2040 was already mounted on the back side of the PCB, we would not be able to use a hot plate to correct the LEDs.

    We added jumper wires to the 5V, GND, and GPIO0 terminals of the RP2040. These jumper wires were then connected to a XIAO SAMD21 M0 development board.

    We uploaded the sketch below to the XIAO, which turns on each LED in the chain one after another in green. This sketch was taken from the example sketches of the Adafruit NeoPixel library.

    #ifdef __AVR__
    #endif
    #define PIN 0
    #define NUMPIXELS 280
    Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
    #define DELAYVAL 50
    void setup() {
    #if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
    clock_prescale_set(clock_div_1);
    #endif
    pixels.begin();
    }
    void loop() {
    pixels.clear();
    for(int i=0; i<NUMPIXELS; i++) { // For each pixel...
    pixels.setPixelColor(i, pixels.Color(0, 150, 0));
    pixels.show();
    delay(DELAYVAL);
    }
    }

View all 18 instructions

Enjoy this project?

Share

Discussions

Does this project spark your interest?

Become a member to follow this project and never miss any updates