Snake Game Console MAX

Hey everyone! Presenting the Snake Game Console MAX

The updated Snake Game Console incorporates two RGB 64x32 P3 matrix panels into a single ultrawide 128x32 display. It uses the same PICO 2 display driver as the previous project, but I designed a new 3D-printed frame to accommodate both displays adequately, complete with integrated handgrips and a D-pad buttons PCB for snake control.

We developed the original Snake game by reusing and tweaking code from the previous Snake Game project. The game's focus stays on a simple snake object, which you control with four directional buttons to aim for randomly appearing red dots around the LED grid. Every time the snake eats a dot, it grows longer, and your score (shown in the upper-right corner) increases accordingly.

This version includes a visible border around the entire display. If the snake hits the wall, the game stops immediately, adding an additional level of difficulty to the game experience.

We've also added a Speed Up option that allows the snake to move quicker when any button is held down for a second in the direction it's moving.

The console is powered by an inbuilt 3.7V 2600mAh lithium-ion battery, making it completely portable and easy to pick up and play anywhere.

This Instructables is about the full build process of thsi project so kerts get started with the build.

Supplies

These were the components used in this build:

Custom PCBs (Provided by PCBWAY)
Raspberry Pi PICO 2
RGB MATRIX PANEL 64x32 P3 x 2
3D-Printed Parts
PICO Driver Board (from previous project)
Li-ion Cell 3.7V 2900mAh 18650
Connecting Wires

64x32 P4 RGB Matrix

For this project, we are combining two 64x32 P3 RGB Matrix panels to create a larger 128x32 P3 RGB Matrix Panel.

You can click the link below to read my brief introduction to this matrix panel.

https://www.instructables.com/64x32-Matrix-Panel-Setup-With-PICO-2/

This panel is powered by the HUB75 interface, which uses a variety of control pins such as RGB, address, clock, data latch, and output enable pins.

The row-column scanning approach is enabled via the HUB75 connection, which shifts a row of pixel data into a shift register. A demultiplexer is then used to select which rows to display. The HUB75 connection features RGB channels, addressing pins A, B, C, and D, a clock signal (CLK), a latch signal (LAT), and an output enable (OE) pin.

We can also connect additional panels in pairs to form a chain using the IN and OUT connections provided.

One of the challenges of connecting numerous panels is ensuring that the control solution (PICO 2) can handle the increased data load of two or more displays.

This matrix was produced by Waveshare, and more thorough details on the Matrix board may be found at the wiki page below:

https://www.waveshare.com/wiki/RGB-Matrix-P3-64x32

Updated Console Design

The first step in developing the Snake Game Console MAX was to create an updated 3D model of the housing to suit the improved dual-display setup. The new version combines two 64×32 P3 RGB LED matrix panels into a seamless 128×32 display, resulting in an even wider playfield.

We reused the original switch board and PICO driver circuit, securely putting them below the matrix. To structurally unite the two panels, we created and incorporated two customized Frame Holder components that link panels and keep them aligned.

The left and right handgrips were also rebuilt, not just to handle the larger chassis, but also to improve comfort. The revised grips are more ergonomic, making lengthy gameplay sessions more enjoyable.

As before, the handgrips are fastened to the matrix's back via M2.5 bolts and built-in M2.5 inserts. Four M2 screws hold the side button board in place.

After 3D model was completed, the mesh files for both grips and the new frame holders were exported and 3D printed in white PLA on our new Creality K10 Max with Hyper PLA @ 0.2mm layer height, 0.4mm nozzle, and 600 mm/s acceleration speed.

Downloads

PI DISPLAY v22.step

BOT.3mf

LEFT.3mf

RIGHT.3mf

TOP.3mf

Pico Display Driver & Switch Board

Let's have a look at the hardware used for this project. We used the PICO Driver and Switch boards from the previous Snake game console build.

The PICO Driver board connects a Raspberry Pi PICO 2 to a HUB75 connector. The matrix's HUB75 pins (CON 16) are linked to the PICO's GPIO pins in the following order: A to GPIO19, B to GPIO16, C to GPIO18, D to GPIO20, E to GPIO22, CLK to GPIO11, LAT/STB to GPIO12, OE to GPIO13, R1 to GPIO2, G1 to GPIO3, B1 to GPIO4, R2 to GPIO5, G2 to GPIO8, and B2 to GPIO9.

We included a CON5 connector for buttons, with four pins connected to PICO's GPIO6, GPIO7, GPIO14, and GPIO15. GND is connected to CON5's fifth pin. Each GPIO will be pulled to GND by the button board that connects to this CON5, which PICO will recognize as a button press.

We also used a power management IC, the IP5306, a fully integrated multi-function power management SoC, to power the complete system.

It can provide a steady 5V 2.1A using 3.7V as an input, which can be used to power any 5V device—in our instance, the matrix and PICO 2.

You can check out the IP5306 Datasheet for more info: http://www.injoinic.com/wwwroot/uploads/files/20200221/0405f23c247a34d3990ae100c8b20a27.pdf

The Switch Board contains four push buttons that are coupled to a CON5 terminal, which will be used to connect the Switch Board to the PICO 2 GPIO Pins.

PCBWAY

In this project we are reusing two PCBs from the previous Snake Game Console project that were the Button board and the PICO driver board. Two orders were made: one for the button board and one for the PICO driver board.

The button board PCB was ordered in white solder mask and black silkscreen, while the PICO Driver PCB was ordered in blue solder mask and white silkscreen.

After placing the order, the PCBs were received within a week, and the PCB quality was pretty great.

Over the past ten years, PCBWay has distinguished themselves by providing outstanding PCB manufacturing and assembly services, becoming a trusted partner for countless engineers and designers worldwide.

PCBWay is celebrating its 11th anniversary with a festive community event running from June 18 to July 18, 2025. Participants can unlock a series of six unique cards by completing fun and engaging activities such as reading a special letter, claiming coupons, watching a promotional video, placing an order, purchasing badges or discounted items, and uploading a project.

Each completed task unlocks a card, and collecting all six grants you an additional lucky draw chance. It's a great way to get involved, showcase your work, and maybe even win something exciting along the way.

You guys can check out PCBWAY if you want great PCB service at an affordable rate.

Frame Assembly

We began the assembly process by connecting the two matrix panels together using the display frames placed over the M2.5 inserts of the two matrix panels.
We then used four M2.5 bolts to secure each display frame to the back side of the matrix panel.
Next, on both sides of the matrix panel, we have attached the handgrip, which is placed over M.25 inserts, allowing us to attach bolts to tighten the handgrip part to the matrix.

PICO Driver Assembly

Next follows the PICO Driver Assembly, which begins by connecting the two matrix panels in a chain by attaching the included HUB75 Ribbon Cable connector to Dout of the first matrix and the other end to the Din of the second matrix panel. This is comparable to the way RGB LED WS2812 LEDs are connected.
We are employing 2 RGB matrix panels, which means we need to provide power to both panels. To do so, we connected two power connectors in parallel with our PICO Driver's 5V and GND. Then connect both female power connectors to both matrix male power connectors.
Next, the HUB 75 connector of the PICO Driver is linked with the Din of the first matrix.
After all of the connectors are plugged in, we align the PICO Driver with the screw bosses added to the Display Frame and secure it with four M2 self-tapping screws.

Switch Board Assembly

We install the Switch Board over the four screw bosses on the Left Hand Grip and then use four M2 screws to secure it to the Left Grip part.

WIRING

Now follows the wiring step, which requires five long connecting wires to link the Switch Board to the I/O of the PICO Driver Board.

We begin by using a soldering iron to connect wires to the Switch Board's UP, DOWN, LEFT, RIGHT, and GND connections.
Following the wiring order, the Connecting wires attached to the Switch Board's Terminals are all linked to their respective GPIO Pins on the PICO Driver board. We're using the provided Wiring Diagram to connect the switch board and pico driver together.

Updated CODE

This is the Code we used in this project and it's a simple one.

#include <Adafruit_Protomatter.h>

// Pin definitions

#define R1 2

#define G1 3

#define B1 4

#define R2 5

#define G2 8

#define B2 9

#define A 10

#define B 16

#define C 18

#define D 20

#define CLK 11

#define LAT 12

#define OE 13

// Button pins

#define BUTTON_UP 6

#define BUTTON_DOWN 7

#define BUTTON_LEFT 14

#define BUTTON_RIGHT 15

// Panel settings

#define PANEL_WIDTH 64

#define PANEL_HEIGHT 32

#define NUM_PANELS 2

#define WIDTH (PANEL_WIDTH * NUM_PANELS)

#define HEIGHT PANEL_HEIGHT

#define SNAKE_LENGTH 8

uint8_t rgbPins[] = { R1, G1, B1, R2, G2, B2 };

uint8_t addrPins[] = { A, B, C, D };

Adafruit_Protomatter matrix(WIDTH, HEIGHT, 1, rgbPins, 4, addrPins, CLK, LAT, OE, false);

struct SnakeSegment {

int x;

int y;

};

SnakeSegment snake[WIDTH * HEIGHT];

int snakeLength = SNAKE_LENGTH;

int dx = 1, dy = 0;

uint16_t snakeColor = matrix.color565(0, 255, 0);

uint16_t foodColor = matrix.color565(255, 0, 0);

uint16_t borderColor = matrix.color565(255, 255, 255);

uint16_t gameOverColor = matrix.color565(255, 0, 0);

int foodX, foodY;

int score = 0;

bool gameOver = false;

// Speed control variables

#define BASE_DELAY 100 // Normal speed

#define FAST_DELAY 50 // Faster speed when button is held

void placeFood() {

bool foodOnSnake;

do {

foodX = random(1, WIDTH - 1); // Ensure food doesn't spawn on the border

foodY = random(1, HEIGHT - 1);

foodOnSnake = false;

for (int i = 0; i < snakeLength; i++) {

if (snake[i].x == foodX && snake[i].y == foodY) {

foodOnSnake = true;

break;

}

} while (foodOnSnake);

}

void setup() {

matrix.begin();

pinMode(BUTTON_UP, INPUT_PULLUP);

pinMode(BUTTON_DOWN, INPUT_PULLUP);

pinMode(BUTTON_LEFT, INPUT_PULLUP);

pinMode(BUTTON_RIGHT, INPUT_PULLUP);

for (int i = 0; i < snakeLength; i++) {

snake[i] = { WIDTH / 2 - i, HEIGHT / 2 };

}

placeFood();

matrix.fillScreen(0);

matrix.show();

}

void drawScore() {

matrix.setCursor(WIDTH - 20, 2);

matrix.setTextColor(matrix.color565(255, 255, 255));

matrix.print(score);

}

void drawBorder() {

for (int x = 0; x < WIDTH; x++) {

matrix.drawPixel(x, 0, borderColor); // Top border

matrix.drawPixel(x, HEIGHT - 1, borderColor); // Bottom border

}

for (int y = 0; y < HEIGHT; y++) {

matrix.drawPixel(0, y, borderColor); // Left border

matrix.drawPixel(WIDTH - 1, y, borderColor); // Right border

}

void checkGameOver() {

if (snake[0].x <= 0 || snake[0].x >= WIDTH - 1 ||

snake[0].y <= 0 || snake[0].y >= HEIGHT - 1) {

gameOver = true; // Snake hits the border

}

for (int i = 1; i < snakeLength; i++) {

if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {

gameOver = true;

break;

}

void resetGame() {

snakeLength = SNAKE_LENGTH;

dx = 1; dy = 0;

score = 0;

gameOver = false;

for (int i = 0; i < snakeLength; i++) {

snake[i] = { WIDTH / 2 - i, HEIGHT / 2 };

}

placeFood();

}

void drawGameOver() {

matrix.fillScreen(gameOverColor);

uint16_t black = matrix.color565(0, 0, 0);

matrix.setCursor((WIDTH / 2) - 30, (HEIGHT / 2) - 4);

matrix.setTextColor(black);

matrix.print("Game Over!");

matrix.setCursor(WIDTH - 20, 2);

matrix.print(score);

}

void loop() {

if (gameOver) {

drawGameOver();

matrix.show();

delay(5000);

resetGame();

return;

}

// Check button states and update direction

if (!digitalRead(BUTTON_UP) && dy == 0) { dx = 0; dy = -1; }

else if (!digitalRead(BUTTON_DOWN) && dy == 0){ dx = 0; dy = 1; }

else if (!digitalRead(BUTTON_LEFT) && dx == 0){ dx = -1; dy = 0; }

else if (!digitalRead(BUTTON_RIGHT) && dx == 0){ dx = 1; dy = 0; }

// Determine delay based on button press

int currentDelay = BASE_DELAY;

if (!digitalRead(BUTTON_UP) || !digitalRead(BUTTON_DOWN) ||

!digitalRead(BUTTON_LEFT) || !digitalRead(BUTTON_RIGHT)) {

currentDelay = FAST_DELAY; // Reduce delay when holding a button

}

// Move snake

for (int i = snakeLength - 1; i > 0; i--) {

snake[i] = snake[i - 1];

}

snake[0].x += dx;

snake[0].y += dy;

if (snake[0].x == foodX && snake[0].y == foodY) {

snakeLength++;

score++;

placeFood();

}

matrix.fillScreen(0);

drawBorder(); // Draw border each frame

for (int i = 0; i < snakeLength; i++) {

matrix.drawPixel(snake[i].x, snake[i].y, snakeColor);

}

matrix.drawPixel(foodX, foodY, foodColor);

drawScore();

matrix.show();

checkGameOver();

delay(currentDelay); // Adjust speed dynamically based on input

}

This code we are using is the same as the previous Snake Game console project but with a few alterations that we are now going to explain.

Let's start with the Panel Layout, we are chaining two 64×32 RGB panels side by side to form a single ultra-wide 128×32 display.

#define PANEL_WIDTH 64

#define PANEL_HEIGHT 32

#define NUM_PANELS 2

#define WIDTH (PANEL_WIDTH * NUM_PANELS)

#define HEIGHT PANEL_HEIGHT

This expands our coordinate system:

X-axis: 0 to 127 (128 total)
Y-axis: 0 to 31 (32 total)

These are the map pins for RGB data and address selection:

uint8_t rgbPins[] = { R1, G1, B1, R2, G2, B2 };

uint8_t addrPins[] = { A, B, C, D };

Border Logic

void drawBorder() {

for (int x = 0; x < WIDTH; x++) {

matrix.drawPixel(x, 0, borderColor); // Top

matrix.drawPixel(x, HEIGHT - 1, borderColor); // Bottom

}

for (int y = 0; y < HEIGHT; y++) {

matrix.drawPixel(0, y, borderColor); // Left

matrix.drawPixel(WIDTH - 1, y, borderColor); // Right

}

The border is a white frame drawn around all four edges of the display. we call drawBorder() in every loop() iteration after clearing the screen to ensure it stays visible.

And here's where it becomes deadly:

if (snake[0].x <= 0 || snake[0].x >= WIDTH - 1 ||

snake[0].y <= 0 || snake[0].y >= HEIGHT - 1) {

gameOver = true; // Snake hits the border

}

The head of the snake is checked against the boundaries. If it collides with any edge (including those pixels used by the border), the game ends.

Variable Speed

int currentDelay = BASE_DELAY;

if (!digitalRead(BUTTON_UP) || !digitalRead(BUTTON_DOWN) ||

!digitalRead(BUTTON_LEFT) || !digitalRead(BUTTON_RIGHT)) {

currentDelay = FAST_DELAY;

}

When any direction button is being held, currentDelay drops from 100 ms to 50 ms, effectively doubling the snake’s speed. This creates a satisfying "dash" effect without complicating the input system or requiring a new button.

RESULT & CONCLUSION

The project resulted in an even longer Snake Game Console, transforming a nostalgic classic into a wide-screen, portable gaming experience. This version's dual 64×32 RGB P3 matrix panels, flawlessly combined into a 128×32 display, provide a more immersive gaming experience and better visual feedback.

The addition of a border brings the classic arcade challenge to life—hit the wall, and the game is over. Dynamic speed control increases intensity by allowing gamers to accelerate with a single button press. The sleek housing, replete with ergonomic handles and a snappy D-pad, makes it not only useful but also enjoyable to hold and use.

Overall, this is a polished and portable development of my original Snake Game Console, combining code enhancements, hardware reusability, and intelligent 3D design to create a unified and extremely entertaining package.

Please let me know if you require any additional assistance; all the documents, files, and code are included in the article.

In addition, we appreciate PCBWAY's support of this project. Visit them for a variety of PCB-related services, such as stencil and PCB assembly services, as well as 3D printing services

Thanks for reaching this far, and I will be back with a new project pretty soon.

Peace.