Build Instructions

Collapse

• 1

  PCB Assembly

  • 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.

• 2

  Console Assembly

  • 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.
• 3

  CODE

  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.

View all 4 instructions