• Using a solder paste dispenser needle, we begin the PCB assembly process by putting solder paste on each component pad.
• Next, we pick and place the SMD Switch in its location using an ESD Tweezer.
• Subsequently, we remove the board and set it on our Reflow Hotplate, which raises the PCB's temperature from below to the point at which the solder paste melts and the SMD components are all connected to their pads.
• We attached the pads of the two CON7 Female Header Pin connectors that we inserted from the back side of the PCB to the location of the XIAO Microcontroller.
• We soldered the OLED into place after adding it from the top side.

Board assembly is now complete.

• Connecting the 9mm PCB standoffs to the top layer of the board via its four mounting holes is how we begin the layer assembly procedure.
• The top layer board was flipped, and the two 3D-printed switches were inserted into their designated slots.
• Next, the midlayer was positioned from the bottom of the top layer.
• We then placed 3D-printed left and right handgrips over the midlayer and secured them with two M2.5 screws to the PCB standoffs.
• After attaching both handhrips to the standoffs that connect the top and middle layers of the PCB, we installed the XIAO ESP32 and completed our console assembly.

Let's have a look at the code we built, and its a simple one.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET    -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

const int buttonUpPin = 1; // Pin for the up button
const int buttonDownPin = 0; // Pin for the down button

const int paddleHeight = 12;
const int paddleWidth = 3;
int playerPaddleY = (SCREEN_HEIGHT - paddleHeight) / 2;
int compPaddleY = (SCREEN_HEIGHT - paddleHeight) / 2;

int ballX = SCREEN_WIDTH / 2;
int ballY = SCREEN_HEIGHT / 2;
int ballVelocityX = 2;
int ballVelocityY = 2;

bool isGameOver = false;
bool playerWin = false;

void setup() {
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for (;;);
  }
  // Clear the Adafruit splash screen
  display.clearDisplay();
  display.display();
  delay(2000);

  // Display the welcome screen
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 10);
  display.print("PONG PRO");
  display.display();
  delay(2000);

  pinMode(buttonUpPin, INPUT_PULLUP);
  pinMode(buttonDownPin, INPUT_PULLUP);
}

void loop() {
  if (isGameOver) {
    display.clearDisplay();
    display.setTextSize(2);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor((SCREEN_WIDTH - 72) / 2, (SCREEN_HEIGHT - 16) / 2);
    if (playerWin) {
      display.print("You Win!");
    } else {
      display.print("You Lose!");
    }
    display.display();
    delay(3000);
    isGameOver = false;
    ballX = SCREEN_WIDTH / 2;
    ballY = SCREEN_HEIGHT / 2;
    playerPaddleY = (SCREEN_HEIGHT - paddleHeight) / 2;
    compPaddleY = (SCREEN_HEIGHT - paddleHeight) / 2;
    return;
  }

  // Update player paddle position
  if (digitalRead(buttonUpPin) == LOW) {
    playerPaddleY = max(playerPaddleY - 1, 0);
  }
  if (digitalRead(buttonDownPin) == LOW) {
    playerPaddleY = min(playerPaddleY + 1, SCREEN_HEIGHT - paddleHeight);
  }

  // Update computer paddle position
  if (ballY < compPaddleY + paddleHeight / 2) {
    compPaddleY = max(compPaddleY - 1, 0);
  }
  if (ballY > compPaddleY + paddleHeight / 2) {
    compPaddleY = min(compPaddleY + 1, SCREEN_HEIGHT - paddleHeight);
  }

  // Update ball position
  ballX += ballVelocityX;
  ballY += ballVelocityY;

  // Check ball collisions with top and bottom
  if (ballY <= 0 || ballY >= SCREEN_HEIGHT - 1) {
    ballVelocityY = -ballVelocityY;
  }

  // Check ball collision with player paddle
  if (ballX <= paddleWidth && ballY >= playerPaddleY && ballY <= playerPaddleY + paddleHeight) {
    ballVelocityX = -ballVelocityX;
  }

  // Check ball collision with computer paddle
  if (ballX >= SCREEN_WIDTH - paddleWidth - 1 && ballY >= compPaddleY && ballY <= compPaddleY + paddleHeight) {
    ballVelocityX = -ballVelocityX;
  }

  // Check ball out of bounds
  if (ballX <= 0) {
    isGameOver = true;
    playerWin = false;
  }
  if (ballX >= SCREEN_WIDTH - 1) {
    isGameOver = true;
    playerWin = true;
  }

  // Clear display
  display.clearDisplay();

  // Draw player paddle
  display.fillRect(0, playerPaddleY, paddleWidth, paddleHeight, SSD1306_WHITE);

  // Draw computer paddle
  display.fillRect(SCREEN_WIDTH - paddleWidth, compPaddleY, paddleWidth, paddleHeight, SSD1306_WHITE);

  // Draw ball
  display.fillRect(ballX, ballY, 1, 1, SSD1306_WHITE);

  // Update display
  display.display();

  delay(30);
}

we are using two buttons to control the paddle. It includes initialization for the display and buttons, variables to track the paddle and ball positions, and game logic to handle ball movement, paddle control, and collision detection.

The game starts with a "PONG PRO" welcome screen and shows "You Win!" or "You Lose!" messages when the game ends, depending on whether the player or the computer missed the ball. The game then resets for another round, continuing in a loop until the device is turned off.

Here's the end result of this simple yet fun build: a super small handheld game device that runs PONG. In this game, our opponent is the computer, and we are playing against it. When the computer misses the ball, a splash screen appears, indicating that we have won; if we miss the ball, a splash screen appears, indicating that we have lost.

Overall, this is a fun little project that is almost finished; however, because this device is powered via USB port, we haven't included a battery, which we will address in the next iteration of this project.

Special thanks to HQ NextPCB for providing components that I've used in this project; check them out for getting all sorts of PCB or PCBA-related services for less cost.

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