Published January 24, 2020 © GPL3+

Handheld Two-Player Pong with NeoPixels

Play Pong with a friend without the need for a screen.

IntermediateFull instructions provided6 hours1,429

Things used in this project

Hardware components

Microchip ATmega8A

WS2812b

Capacitor 1000 µF

Momentary Pushbutton Tall

5v Regulator

16MHz Crystal Oscillator

Software apps and online services

Arduino IDE

Microsoft VS Code

Microchip Studio

Hand tools and fabrication machines

Soldering iron (generic)

Story

The Idea

I have created several projects that involve various flavors of the classic game, Pong. It’s quite simple, as it’s comprised of just two paddles and a ball that can be hit around a screen.

But I wanted to do something different; I wanted to make a game that didn’t require a screen at all — but could instead be played on discrete NeoPixel LEDs. By doing this, a large, yet low-power display could be formed and run many varieties of games.

The Components

First and foremost, there must be a way to view the game while it’s being played, which is why I went with 48 LEDs laid out in an 8 by 6 grid.

They are attached to a capacitor which smooths out the power going to the LEDs, resulting in less interference and more stability. The microcontroller I chose was the ATmega8A, which is a small, cheap MCU that has plenty of RAM and speed to run the game. It also has abundant GPIO pins for interfacing with the buttons.

Designing the PCB

I began the PCB design phase by first making a schematic, which shows the components used and how they interface with each other. The ATmega8A is connected to a 16MHz oscillator so it doesn’t have to rely on its internal 8MHz one, resulting in a drastic speed increase. The voltage regulator takes in a 9v input and knocks it down to 5v for the MCU and LEDs.

The WS2812b LEDs are connected in a cascading series, where each LED is connected to the previous one’s data output pin into its data input pin.

The PCB is quite simple, as it contains the logic and supporting components on one side (the MCU, reset button, etc.) and the LEDs and buttons on the other.

I did this to make the LED side cleaner to view, as unsightly components would be hidden underneath.

I would like to thank pcbgogo.com for providing the PCBs to me.

Game Programming

The game of Pong is quite simple: two paddles hit a ball back and forth until the ball goes offscreen. Although these rules aren’t that complex, the implementation can be very difficult. First, an instance of the Adafruit_NeoPixel class is created and called ‘pixels’, which will handle all neopixel-related functions. Next, default values are placed into their respective variables, such as the positions for the paddles and ball, along with the colors for each. Because the NeoPixels were not placed in order on the PCB (a bit of an oversight), I created a lookup table that can be placed into EEPROM that maps each pixel’s actual location to its virtual one.

In order to maintain adequate speed, delays are non-blocking, as the millis() function is used in conjunction with variables that measure the time between updates. For instance, the code has a definition called FRAME_DELAY with a value of 40ms, which means that whenever millis() returns a value that is >= 40, a new frame is drawn. Frames are composed of the paddles and the ball, which are displayed by using the Adafruit_NeoPixel::setPixelColor() function and calling pixels.show() after.

Collision checking happens every 20ms by default. Three things are checked: the ball intersecting player 1’s paddle, the ball intersecting player 2’s paddle, or the ball hitting a wall. If the ball goes past a player’s paddle, then the opponent gains a point, the scores get displayed, and the game is reset for an additional round.

Playing the Game and Future Plans

Playing Pong on a NeoPixel PCB is quite fun against an opponent. In the future, I would like to add more games, such as Snake or simple Tetris. I also plan on designing a 3D-printable case that can be used to support the PCB and shield the components underneath.

Code

#include <Adafruit_NeoPixel.h>
#include <EEPROM.h>
#include "offset_table.h"

#ifdef __AVR__
 #include <avr/power.h>
#endif

#define PIXEL_NUM 48
#define WIDTH 8
#define HEIGHT 6

#define LED_PIN 4
#define WRITE_ORDER_DATA false

// 40 ms between frames
#define FRAME_DELAY 40
#define MOVE_DELAY 20

Adafruit_NeoPixel pixels(PIXEL_NUM, LED_PIN, NEO_GRB + NEO_KHZ800);

// Paddle 1 left, paddle 1 right, paddle 2 left, paddle 2 right
const uint8_t buttonPins[4] = {3, 1, 2, 0};

uint32_t lastFrameUpdate = 0, lastMoveUpdate = 0;

// Paddle 1, paddle 2, ball
const uint32_t colors[3] = {0x000010D0, 0x000D010, 0x00E5A500};

// Paddle 1 x/y, paddle 2 x/y, ball x/y
uint8_t piecePositions[6] = {WIDTH/2 - 1, 0, WIDTH/2 - 1, HEIGHT-1, WIDTH / 3, HEIGHT/3};
int8_t ballVector[2] = {1, 1};

uint8_t p1Wins = 0, p2Wins = 0;

void setup()
{
    pixels.begin();
    pixels.clear();
    pixels.setBrightness(50);
    if(WRITE_ORDER_DATA)
    {
        for(int i=0; i<PIXEL_NUM; i++)
        {
            EEPROM.write(i, offsets[i]);
            pixels.setPixelColor(EEPROM.read(i), 0x002050FF);
            pixels.show();
            delay(400);
        }
        // Program is done, ready to flash the game
        while(1);
    }
    for(int i=0; i<4; i++)
    {
        pinMode(buttonPins[i], INPUT_PULLUP);
    }
    lastFrameUpdate = millis();
    lastMoveUpdate = millis();
}

void loop()
{
    if(millis() - FRAME_DELAY >= lastFrameUpdate)
    {
        drawFrame();
        lastFrameUpdate = millis();
    }
    // Check button states
    if(millis() - MOVE_DELAY >= lastMoveUpdate)
    {
        if(digitalRead(buttonPins[0]))
        {
            if(piecePositions[0]>0) piecePositions[0]--;
        }
        else if(digitalRead(buttonPins[1]))
        {
            if(piecePositions[0]<WIDTH-2) piecePositions[0]++;
        }
        if(digitalRead(buttonPins[2]))
        {
            if(piecePositions[2]>0) piecePositions[2]--;
        }
        else if(digitalRead(buttonPins[3]))
        {
            if(piecePositions[2]<WIDTH-2) piecePositions[2]++;
        }
        lastMoveUpdate = millis();
    }
    if(checkCollisions()) drawScores();
}

void drawFrame()
{
    pixels.clear();
    // Draw paddles
    pixels.setPixelColor(EEPROM.read(XYtoLED(piecePositions[0], piecePositions[1])), colors[0]);
    pixels.setPixelColor(EEPROM.read(XYtoLED(piecePositions[0]+1, piecePositions[1])), colors[0]);
    pixels.setPixelColor(EEPROM.read(XYtoLED(piecePositions[2], piecePositions[4])), colors[1]);
    pixels.setPixelColor(EEPROM.read(XYtoLED(piecePositions[2]+1, piecePositions[4])), colors[1]);
    // Update ball position
    pixels.setPixelColor(EEPROM.read(XYtoLED(piecePositions[5], piecePositions[6])), colors[2]);
    pixels.show();
}

void resetGame()
{
    piecePositions[0] = WIDTH/2 - 1;
    piecePositions[1] = 0;
    piecePositions[2] = WIDTH/2 - 1;
    piecePositions[3] = HEIGHT-1;
    piecePositions[4] = WIDTH / 3;
    piecePositions[5] = HEIGHT/3;
    drawFrame();
    delay(1000);
}

bool checkCollisions()
{
    if(piecePositions[5] <= 0)
    {
        // If both p1 x and ball x are the same
        if(piecePositions[4] == piecePositions[0] || piecePositions[4] == piecePositions[0] + 1)
        {
            // Reflect ball
            ballVector[1] = -ballVector[1];
            return false;
        }
        else
        {
            // Player 1 has lost
            p2Wins++;
            return true;
        }
    }
    else if(piecePositions[5] >= HEIGHT-1)
    {
        if(piecePositions[4] == piecePositions[2] || piecePositions[4] == piecePositions[2] + 1)
        {
            ballVector[1] = -ballVector[1];
            return false;
        }
        else
        {
            // Player 2 has lost
            p1Wins++;
            return true;
        }
    }
    if(piecePositions[4] <= 0)
    {
        ballVector[0] = -ballVector[0];
        return false;
    }
    else
    {
        ballVector[0] = -ballVector[0];
        return false;
    }
    
}

void drawScores()
{
    for(int i = 0; i < p1Wins; i++)
    {
        pixels.setPixelColor(EEPROM.read(i), colors[0]);
    }
    for(int i = p1Wins; i < p2Wins + p1Wins; i++)
    {
        pixels.setPixelColor(EEPROM.read(i), colors[1]);
    }
    pixels.show();
    delay(3000);
    resetGame();
}

uint8_t XYtoLED(uint8_t x, uint8_t y)
{
    return (y * WIDTH) + x;
}

Credits

Evan Rust

120 projects • 1053 followers

IoT, web, and embedded systems enthusiast. Contact me for product reviews or custom project requests.

Handheld Two-Player Pong with NeoPixels

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The Idea

The Components

Designing the PCB

Game Programming

Playing the Game and Future Plans

Schematics

Schematic

PCB

Code

Handheld Pong

offset_table.h

Credits

Evan Rust

Comments

Embed the widget on your own site

Handheld Two-Player Pong with NeoPixels

Handheld Two-Player Pong with NeoPixels

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The Idea

The Components

Designing the PCB

Game Programming

Playing the Game and Future Plans

Schematics

Schematic

PCB

Code

Handheld Pong

offset_table.h

Credits

Evan Rust

Comments

Related channels and tags