Final project

PinSocc Ball website

Quick navigation

Slide Video Presentation Q&A BOM Diagrams Downloads Assembly Future evolutions License

This project is a game that combines concepts from both a pinball and table football. The gameplay consists of scoring goals in the opponent’s goal using two flippers similar to those found in a pinball machine.

Each player controls two flippers acting as if they were a football goalkeeper’s hands, trying to defend their own goal while also attempting to send the ball toward the rival side and score.

The goal is to create a simple, fun, and engaging experience based on reflexes, timing, and player interaction.

Throughout the development process, I integrated 2D and 3D design, digital fabrication, electronics, programming, and mechanical assembly to build a fully functional system. The result is an interactive machine that combines skill, reflexes, and competition, showing how the different disciplines learned during Fab Academy can come together in a single project.

You can go to to de Develoment page to see the evolution/tests or to de Proposal page to first understand the initial idea.

Slide

Video

PINSOCC BALL - Beni Álvarez | FabAcademy26 - FabLab León

High quality video available on Vimeo ↗️.

PinSocc Ball song (radio version)

'PinSocc Ball song' is a song created specifically in Suno for the final project presentation video. Here is the full version.

Presentation

On June 8th, 2026, I presented my final project, PinSocc Ball, during the first day of Fab Academy 2026 final presentations.

PinSocc Ball is a game that combines the mechanics of a pinball machine and a table football game, inspired by an arcade machine I played many years ago and never found again. This project integrates digital fabrication, electronics design and production, embedded programming, networking, and system integration into a fully functional interactive machine.

The following video shows the final project FA'26 presentation:

PINSOCC BALL presentation 8th june 2026 - Beni Álvarez | FabAcademy26 - FabLab León

You can also watch all the presentations from the first day of Fab Academy 2026 final project presentations through the following Vimeo link.

Person portrait — Neil Gershenfeld (Jun 8, 2026)

Q & A

This project is a game that combines concepts from both a pinball machine and a table football game. The gameplay consists of scoring goals in the opponent’s goal using two flippers similar to those found in a pinball machine.

Each player controls two flippers acting as if they were a football goalkeeper’s hands, trying to defend their own goal while also attempting to send the ball toward the rival side and score.

The goal is to create a simple, fun, and engaging experience based on reflexes, timing, and player interaction.

The main inspiration for this project comes from an arcade game I played when I was younger and that I have never seen again since then. Although pinball machines and table football games still exist today, that machine combined elements of both concepts in a different way and left a strong impression on me.

After deciding to develop this idea, I researched similar projects and found several examples of two-player pinball machines. However, I could not find any project combining a football field with two opposite goals and gameplay focused on defending and attacking using flippers.

Besides that initial inspiration, I also used references from existing pinball systems, football games, and different mechanical and electronic solutions discovered during the development process.

I will design all the main mechanical and electronic elements required for the project. This includes:

Outer structure and chassis
Playing field
Goal detection system with IR sensors
Game control logic
Automatic ball return system with ramps
Score display
Lighting effects with LEDs

I will also design the necessary PCBs, holders, and custom 3D printed parts required to integrate all the systems together.

Several parts and systems will be designed and manufactured specifically for this project:

Wooden outer case structure
MDF top cover and ball return system (ramps)
Laser engraved and cut playing field
3D printed parts such as hand flippers and PCB holders/cases
Custom electronic system and PCBs
LED lighting system and score display
Game control system and logic

Different fabrication processes learned during Fab Academy will be used throughout the project:

CNC milling for manufacturing the wooden structure
2D design and laser cutting/engraving for the playing field
Laser cutting on MDF for the top cover and ramps for the ball return system
3D design and printing for custom components
PCB design and CNC fabrication
Embedded programming
Mechanical and electronic system integration

The combination of all these techniques will allow me to fabricate most of the project instead of relying on external parts.

The project will be evaluated by testing both its technical functionality and the overall user experience.

Some evaluation criteria will include:

Correct operation and responsiveness of the flippers
Accurate goal detection
Reliable operation of the automatic ball return system
Proper score display and lighting effects
Successful integration of all mechanical and electronic systems
Quality of assembly and final appearance
Whether the game feels dynamic, balanced, and enjoyable for different users

Additionally, real user testing will be performed to identify possible improvements and detect any issues or areas that could be optimized.

This project shows how digital fabrication, electronics, embedded programming, networking, and system integration can come together to create a complete and playable product.

Beyond the current prototype, PinSocc Ball has several possible future evolutions, such as a mobile and web platform to store match statistics, manage players, and organize championships.

Other improvements could include an automatic ball elevator system, online rankings, additional game modes, and sound or haptic feedback to make the experience more immersive.

These developments could turn the project from a standalone arcade game into a more connected, scalable, and engaging gaming platform.

See the complete BOM table below

BOM (Bill of Materials)

Prices are in EUR. EUR → USD conversion:

No.	Item	Qty	Unit €	Source	Link
Electronics
1	Xiao ESP32C6	3	4.99	Online	Seeed Studio
2	RGB LEDs stipe WS2812 5V 3m	1	14.85	Online	Bricogeek
3	Seimitsu Arcade button 24mm	6	0.35	Online	Aliexpress
4	IR reflectance sensor	2	1.04	Online	Aliexpress
5	Servo MG996R (metal)	4	3.40	Online	Aliexpress
6	0.96 Inch OLED Module 12864 128x64	1	2.40	Online	Fab Lab Inventory
7	Flat wire 4pins with conectors (3m)	1	2.25	Fab Lab	Fab Lab Inventory
8	PCB	3	1.15	Fab Lab	Fab Lab Inventory
9	Some PCB connectors	15	0.20	Fab Lab	Fab Lab Inventory
10	2 wire cable (m)	2	0.45	Fab Lab	Fab Lab Inventory
Electronics subtotal
Fabrication & assembly
1	15 mm Pine Plywood m2	0.65	24.30	Local supplier	-
2	MDF 3 mm m2	0.33	7.55	Local supplier	-
3	3D printed parts (kg. PLA)	1.15	14.80	FabLab	-
4	Two-layer acrylic m2	0.40	32.90	FabLab	-
5	Vinyl stickers	1	0.90	FabLab	-
6	3x16mm screws (50 units box)	1	2.30	FabLab	-
Fabrication & assembly subtotal
Grand total

System and user diagrams

System diagram User flow diagram

User flow diagram / User experience -AI Generated- (size: 0 Kb -click to enlarge-).

Downloads

Vector files used for laser cutting, engraving and vinyl cutting processes.

Main upper wooden structure of the machine (CNC).

case_up.ai

Editable .ai file for cnc milling.

case_up.dxf

DXF version for cnc milling.

case_up.crv (Cut 2D)

Cut 2D Pro toolpaths.

case_up.nc (GCode)

GCode file.

Lower wooden structure of the machine (CNC).

case_down.ai

Editable .ai file for cnc milling.

case_down.dxf

DXF version for cnc milling.

case_down.crv (Cut 2D)

Cut 2D Pro toolpaths.

case_down.nc (GCode)

GCode file.

Top MDF cover

top_cover.ai top_cover.svg

Playing field design including engraving and cutting references.

game_field.ai game_field.dxf

2D files for the ramps that guide the ball movement inside down case.

ramps.svg ramps.dxf

Graphic files used for decorative vinyl stickers and visual identity.

stickers.cst

All sitckers in Roland Cut Studio software

logo_h.svg

B/W horizontal logo.

logo_v.svg

B/W full logo.

Custom 3D printed components designed specifically for PinSocc Ball.

Rounded corner to eliminate angle.

corner.FCStd corner.stl

Main 3D printed case used for main PCB, oled and control game buttons.

box_main.FCStd (FreeCAD) box_main.stl box_main_upcover.stl

Goal housing used to contain and protect the goal detection system, player buttons and PCB.

box_goal.FCStd (FreeCAD) box_goal.stl box_goal_upcover.stl

Parts to cover, protect and guide wires inside PCB cases.

box_main_SI.FCStd (FreeCAD) box_main_SI.stl box_goal_SI1.FCStd (FreeCAD) box_goal_SI1.stl box_goal_SI2.FCStd (FreeCAD) box_goal_SI2.stl

Player-controlled flipper used to hit the ball during the game.

handflipper.FCStd (FreeCAD) handflipper.stl

Support part used to hold the servo motors MG996R in the correct position.

servo_holder.FCStd (FreeCAD) servo_holder.stl

Support part used to hold the servo motors SG90 in the correct position.

servo_holder_SG90.FCStd (FreeCAD) servo_holder_SG90.stl

Hinge-like part used for mechanical articulation and movement. Downloaded from makerworld.com

hingle.stl

Box that retains the ball after exit.

ball_case.FCStd (FreeCAD) ball_case.stl

3D model of the ball downloaded from makerworld.com.

ball.stl

Schematics, PCB layouts and production files used to fabricate the electronic boards.

Main board that controls the central logic of the game, LEDs and OLED.

main_pcb_KiCad.zip

KiCad files

main_pcb_Gerbers.zip

Gerbers

main_pcb_PNGs.zip

PNG files used in modsproject.org for generating the Gcodes files

main_pcb_Gcodes.zip

Roland SRM20 GCodes

main_pcb_ibom.html

KiCad ibom

Boards used in the goal areas for detection and local interaction (buttons and servos).

goal_pcb_KiCad.zip

KiCad files

goal_pcb_Gerbers.zip

Gerbers

goal_pcb_PNGs.zip

PNG files used in modsproject.org for generating the Gcodes files

goal_pcb_Gcodes.zip

Roland SRM20 GCodes

goal_pcb_ibom.html

KiCad ibom

Source code used in the different XIAO boards controlling the game system.

Main firmware responsible for the central logic, score and communication.

PinSoccB_Main.ino

Firmware uploaded to the board installed on the visitor goal side.

PinSoccB_VISITOR.ino

Firmware uploaded to the board installed on the local goal side.

PinSoccB_LOCAL.ino

2D file viewer

Upper wood case Down wood case Top cover Field Ramps Vinyl stickers

Main upper wooden structure of machine (CNC)

Lower wooden structure of machine (CNC)

Top DM cover (Laser engraving and cutting)

Playing field design including engraving and cutting references

2D files for the ramps that guide the ball movement inside down case

Graphic files used for decorative vinyl stickers and visual identity

3D file viewer

Main case Goal case Corner Handflipper Servo holder Ball exit

Main 3D printed case used for main PCB, OLED and control game buttons

Box_main by benialvarez on Sketchfab

Box main upcover by benialvarez on Sketchfab

Box_main_SI by benialvarez on Sketchfab

Goal housing used to contain and protect goal detection system, player buttons and PCB

Box/Case goal by benialvarez on Sketchfab

Box/Case goal upcover by benialvarez on Sketchfab

Box_goal_SI1 by benialvarez on Sketchfab

Box_goal_SI2 by benialvarez on Sketchfab

Rounded corner to eliminate 90º angle

Corner by benialvarez on Sketchfab

Handflipper by benialvarez on Sketchfab

Support part used to hold the servo motors in correct position. Options: MG996R & SG90 servos

Servo holder MG996R by benialvarez on Sketchfab

Servo holder SG90 by benialvarez on Sketchfab

Box thats retains the ball after exit

Ball exit case by benialvarez on Sketchfab

Arduino code viewer

Code · PinSoccB_Main.ino Show code

// Code generated with the help of AI from the prompt described in the documentation; manually reviewed and adapted.

#include <WiFi.h>
#include <WebServer.h>
#include <esp_now.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_NeoPixel.h>

// OLED
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_SDA D4
#define OLED_SCL D5
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// LED STRIP
#define LED_PIN 18
#define NUM_LEDS 106

const uint8_t BAND_BRIGHTNESS = 100;
const uint8_t GOAL_BRIGHTNESS = 200;

Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);

// LED ZONES
const int BAND1_START_A = 0;
const int BAND1_END_A   = 13;
const int BAND1_START_B = 92;
const int BAND1_END_B   = 105;
const int BAND2_START   = 39;
const int BAND2_END     = 67;

const int LOCAL_GOAL_START   = 14;
const int LOCAL_GOAL_END     = 38;
const int VISITOR_GOAL_START = 68;
const int VISITOR_GOAL_END   = 91;

// BUTTONS
#define BUTTON_START_STOP D0
#define BUTTON_RESET      D1

// GAME CONFIG
const unsigned long MATCH_DURATION_SECONDS = 180;
const unsigned long RESET_HOLD_TIME = 2000;
const unsigned long GOAL_MESSAGE_TIME = 1500;

const unsigned long START_BLINK_TIME = 2000;
const unsigned long END_RED_TIME = 5000;
const unsigned long LED_BLINK_INTERVAL = 250;
const unsigned long GOAL_LED_TIME = 2000;

// WIFI
const char* ssid = "PinSoccBall";
const char* password = "12345678";
WebServer server(80);

// ESP-NOW
#define EVENT_GOAL_LOCAL   1
#define EVENT_GOAL_VISITOR 2

typedef struct {
  uint8_t boardID;
  uint8_t eventType;
} EspNowMessage;

volatile bool espNowGoalLocalPending = false;
volatile bool espNowGoalVisitorPending = false;

// GAME STATE
bool gameRunning = false;
unsigned long remainingTime = MATCH_DURATION_SECONDS;
unsigned long lastTimerUpdate = 0;

int localScore = 0;
int visitorScore = 0;

bool showingGoal = false;
unsigned long goalMessageStart = 0;
String lastGoalTeam = "";

// LED STATE
enum LedMode {
  LED_WAITING,
  LED_START_BLINK,
  LED_GAME_GREEN,
  LED_LAST_SECONDS_RED_BLINK,
  LED_END_RED,
  LED_OFF
};

LedMode ledMode = LED_WAITING;
unsigned long ledModeStart = 0;
unsigned long lastBlinkTime = 0;
bool blinkState = false;

// GOAL EFFECT
enum GoalType {
  GOAL_NONE,
  GOAL_LOCAL,
  GOAL_VISITOR
};

GoalType currentGoalEffect = GOAL_NONE;
bool goalEffectActive = false;
unsigned long goalEffectStart = 0;
unsigned long lastGoalBlinkTime = 0;
bool goalBlinkState = false;

// BUTTON STATE
bool lastStartButton = HIGH;
bool lastResetButton = HIGH;

unsigned long resetPressStart = 0;
bool resetWasPressed = false;

// -------------------- COLORS --------------------
uint32_t bandGreen() {
  return strip.Color(0, BAND_BRIGHTNESS, 0);
}

uint32_t bandRed() {
  return strip.Color(BAND_BRIGHTNESS, 0, 0);
}

uint32_t goalGreen() {
  return strip.Color(0, GOAL_BRIGHTNESS, 0);
}

uint32_t goalRed() {
  return strip.Color(GOAL_BRIGHTNESS, 0, 0);
}

uint32_t offColor() {
  return strip.Color(0, 0, 0);
}

// -------------------- TIME --------------------
String formatTime(unsigned long seconds) {
  int minutes = seconds / 60;
  int secs = seconds % 60;

  char buffer[6];
  sprintf(buffer, "%02d:%02d", minutes, secs);

  return String(buffer);
}

// -------------------- LED FUNCTIONS --------------------
void setLedRange(int startLed, int endLed, uint32_t color) {
  for (int i = startLed; i <= endLed; i++) {
    if (i >= 0 && i < NUM_LEDS) {
      strip.setPixelColor(i, color);
    }
  }
}

void setBands(uint32_t color) {
  setLedRange(BAND1_START_A, BAND1_END_A, color);
  setLedRange(BAND1_START_B, BAND1_END_B, color);
  setLedRange(BAND2_START, BAND2_END, color);
}

void setLocalGoal(uint32_t color) {
  setLedRange(LOCAL_GOAL_START, LOCAL_GOAL_END, color);
}

void setVisitorGoal(uint32_t color) {
  setLedRange(VISITOR_GOAL_START, VISITOR_GOAL_END, color);
}

void clearStrip() {
  strip.clear();
  strip.show();
}

void showBands(uint32_t color) {
  strip.clear();
  setBands(color);
  strip.show();
}

void setLedMode(LedMode newMode) {
  ledMode = newMode;
  ledModeStart = millis();
  lastBlinkTime = millis();
  blinkState = false;
}

void startGoalEffect(GoalType goalType) {
  currentGoalEffect = goalType;
  goalEffectActive = true;
  goalEffectStart = millis();
  lastGoalBlinkTime = millis();
  goalBlinkState = false;
}

void updateGoalEffect() {
  unsigned long now = millis();

  if (now - goalEffectStart >= GOAL_LED_TIME) {
    goalEffectActive = false;
    currentGoalEffect = GOAL_NONE;

    if (gameRunning) {
      if (remainingTime <= 10) {
        setLedMode(LED_LAST_SECONDS_RED_BLINK);
      } else {
        setLedMode(LED_GAME_GREEN);
        showBands(bandGreen());
      }
    }

    return;
  }

  if (now - lastGoalBlinkTime >= LED_BLINK_INTERVAL) {
    lastGoalBlinkTime = now;
    goalBlinkState = !goalBlinkState;

    strip.clear();

    if (gameRunning) {
      if (remainingTime <= 10) {
        setBands(bandRed());
      } else {
        setBands(bandGreen());
      }
    }

    if (goalBlinkState) {
      if (currentGoalEffect == GOAL_LOCAL) {
        setLocalGoal(goalGreen());
        setVisitorGoal(goalRed());
      }

      if (currentGoalEffect == GOAL_VISITOR) {
        setVisitorGoal(goalGreen());
        setLocalGoal(goalRed());
      }
    }

    strip.show();
  }
}

void showEndResultLeds(bool winnerBlinkOn, bool bandsBlinkOn) {
  strip.clear();

  setBands(bandsBlinkOn ? bandRed() : offColor());

  if (localScore > visitorScore) {
    setLocalGoal(winnerBlinkOn ? goalGreen() : offColor());
    setVisitorGoal(goalRed());
  } 
  else if (visitorScore > localScore) {
    setVisitorGoal(winnerBlinkOn ? goalGreen() : offColor());
    setLocalGoal(goalRed());
  } 
  else {
    setLocalGoal(winnerBlinkOn ? goalGreen() : offColor());
    setVisitorGoal(winnerBlinkOn ? goalGreen() : offColor());
  }

  strip.show();
}

void updateLeds() {
  if (goalEffectActive) {
    updateGoalEffect();
    return;
  }

  unsigned long now = millis();

  switch (ledMode) {

    case LED_WAITING:
      break;

    case LED_START_BLINK:
      if (now - lastBlinkTime >= LED_BLINK_INTERVAL) {
        lastBlinkTime = now;
        blinkState = !blinkState;
        showBands(blinkState ? bandGreen() : offColor());
      }

      if (now - ledModeStart >= START_BLINK_TIME) {
        setLedMode(LED_GAME_GREEN);
        showBands(bandGreen());
      }
      break;

    case LED_GAME_GREEN:
      break;

    case LED_LAST_SECONDS_RED_BLINK:
      if (now - lastBlinkTime >= LED_BLINK_INTERVAL) {
        lastBlinkTime = now;
        blinkState = !blinkState;
        showBands(blinkState ? bandRed() : offColor());
      }
      break;

    case LED_END_RED:
      if (now - lastBlinkTime >= LED_BLINK_INTERVAL) {
        lastBlinkTime = now;
        blinkState = !blinkState;
        showEndResultLeds(blinkState, blinkState);
      }

      if (now - ledModeStart >= END_RED_TIME) {
        resetGameAutomatic();
      }
      break;

    case LED_OFF:
      break;
  }
}

// -------------------- DISPLAY --------------------
void updateDisplay() {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);

  if (showingGoal) {
    display.setTextSize(2);
    display.setCursor(30, 5);
    display.println("GOAL");

    display.setTextSize(1);
    display.setCursor(35, 28);
    display.println(lastGoalTeam);

    display.setTextSize(2);
    display.setCursor(28, 43);
    display.print(localScore);
    display.print(" - ");
    display.print(visitorScore);
  } else {
    display.setTextSize(1);
    display.setCursor(0, 0);
    display.println("PinSocc Ball");

    display.setTextSize(2);
    display.setCursor(18, 16);
    display.print(localScore);
    display.print(" - ");
    display.print(visitorScore);

    display.setTextSize(2);
    display.setCursor(32, 40);
    display.println(formatTime(remainingTime));

    display.setTextSize(1);
    display.setCursor(90, 0);
    display.println(gameRunning ? "RUN" : "STOP");
  }

  display.display();
}

// -------------------- GAME FUNCTIONS --------------------
void addGoalLocal() {
  if (!gameRunning) return;

  localScore++;
  showingGoal = true;
  lastGoalTeam = "LOCAL";
  goalMessageStart = millis();

  startGoalEffect(GOAL_LOCAL);

  Serial.println("GOAL LOCAL");

  updateDisplay();
}

void addGoalVisitor() {
  if (!gameRunning) return;

  visitorScore++;
  showingGoal = true;
  lastGoalTeam = "VISITOR";
  goalMessageStart = millis();

  startGoalEffect(GOAL_VISITOR);

  Serial.println("GOAL VISITOR");

  updateDisplay();
}

void toggleStartStop() {
  if (remainingTime == 0) {
    remainingTime = MATCH_DURATION_SECONDS;
    localScore = 0;
    visitorScore = 0;
    showingGoal = false;
    goalEffectActive = false;
    currentGoalEffect = GOAL_NONE;
    setLedMode(LED_WAITING);
    clearStrip();
  }

  gameRunning = !gameRunning;
  lastTimerUpdate = millis();

  if (gameRunning) {
    setLedMode(LED_START_BLINK);
  }

  Serial.println(gameRunning ? "GAME STARTED" : "GAME PAUSED");

  updateDisplay();
}

void resetGame() {
  if (!gameRunning) {
    remainingTime = MATCH_DURATION_SECONDS;
    localScore = 0;
    visitorScore = 0;
    showingGoal = false;

    goalEffectActive = false;
    currentGoalEffect = GOAL_NONE;

    setLedMode(LED_WAITING);
    clearStrip();

    Serial.println("GAME RESET");

    updateDisplay();
  }
}

void resetGameAutomatic() {
  gameRunning = false;
  remainingTime = MATCH_DURATION_SECONDS;
  localScore = 0;
  visitorScore = 0;
  showingGoal = false;

  goalEffectActive = false;
  currentGoalEffect = GOAL_NONE;

  setLedMode(LED_WAITING);
  clearStrip();

  Serial.println("AUTO RESET AFTER END");

  updateDisplay();
}

void finishGame() {
  gameRunning = false;
  remainingTime = 0;

  goalEffectActive = false;
  currentGoalEffect = GOAL_NONE;

  setLedMode(LED_END_RED);

  Serial.println("TIME FINISHED");

  updateDisplay();
}

// -------------------- ESP-NOW RECEIVE --------------------
void onEspNowRecv(const esp_now_recv_info_t *info, const uint8_t *incomingData, int len) {
  if (len != sizeof(EspNowMessage)) {
    return;
  }

  EspNowMessage msg;
  memcpy(&msg, incomingData, sizeof(msg));

  if (msg.eventType == EVENT_GOAL_LOCAL) {
    espNowGoalLocalPending = true;
  }

  if (msg.eventType == EVENT_GOAL_VISITOR) {
    espNowGoalVisitorPending = true;
  }
}

void setupEspNow() {
  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }

  esp_now_register_recv_cb(onEspNowRecv);

  Serial.println("ESP-NOW receiver ready");
}

// -------------------- WEB --------------------
void handleRoot() {
  String html = "";
  html += "<!DOCTYPE html><html><head>";
  html += "<meta charset='UTF-8'>";
  html += "<meta http-equiv='refresh' content='1'>";
  html += "<title>PinSocc Ball</title>";
  html += "<style>";
  html += "body{font-family:Arial;background:#111;color:white;text-align:center;padding:30px;}";
  html += "h1{color:#00ff99;}";
  html += ".score{font-size:60px;margin:20px;}";
  html += ".time{font-size:48px;margin:20px;}";
  html += ".status{font-size:24px;margin-bottom:30px;}";
  html += "a{display:inline-block;font-size:22px;padding:15px 25px;margin:10px;border-radius:10px;text-decoration:none;color:white;}";
  html += ".local{background:#00aaff;}";
  html += ".visitor{background:#ff6600;}";
  html += ".control{background:#555;}";
  html += "</style></head><body>";

  html += "<h1>PinSocc Ball</h1>";

  html += "<div class='score'>";
  html += String(localScore);
  html += " - ";
  html += String(visitorScore);
  html += "</div>";

  html += "<div class='time'>";
  html += formatTime(remainingTime);
  html += "</div>";

  html += "<div class='status'>";
  html += gameRunning ? "RUNNING" : "STOP";
  html += "</div>";

  html += "<a class='local' href='/goalLocal'>GOAL LOCAL</a>";
  html += "<a class='visitor' href='/goalVisitor'>GOAL VISITOR</a>";
  html += "<br>";
  html += "<a class='control' href='/startStop'>START / STOP</a>";
  html += "<a class='control' href='/reset'>RESET</a>";

  html += "</body></html>";

  server.sendHeader("Cache-Control", "no-store");
  server.send(200, "text/html", html);
}

void redirectHome() {
  server.sendHeader("Location", "/");
  server.send(303);
}

void setupWebServer() {
  server.on("/", handleRoot);

  server.on("/goalLocal", []() {
    addGoalLocal();
    redirectHome();
  });

  server.on("/goalVisitor", []() {
    addGoalVisitor();
    redirectHome();
  });

  server.on("/startStop", []() {
    toggleStartStop();
    redirectHome();
  });

  server.on("/reset", []() {
    resetGame();
    redirectHome();
  });

  server.begin();
}

// -------------------- SETUP --------------------
void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(BUTTON_START_STOP, INPUT_PULLUP);
  pinMode(BUTTON_RESET, INPUT_PULLUP);

  Wire.begin(OLED_SDA, OLED_SCL);

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("OLED not found");
    while (1);
  }

  strip.begin();
  clearStrip();

  WiFi.mode(WIFI_AP_STA);
  WiFi.softAP(ssid, password);

  setupEspNow();

  Serial.println("WiFi AP started");
  Serial.print("SSID: ");
  Serial.println(ssid);
  Serial.print("Password: ");
  Serial.println(password);
  Serial.print("IP: ");
  Serial.println(WiFi.softAPIP());

  setupWebServer();

  updateDisplay();
}

// -------------------- LOOP --------------------
void loop() {
  server.handleClient();

  if (espNowGoalLocalPending) {
    espNowGoalLocalPending = false;
    Serial.println("ESP-NOW RECEIVED: LOCAL GOAL");
    addGoalLocal();
  }

  if (espNowGoalVisitorPending) {
    espNowGoalVisitorPending = false;
    Serial.println("ESP-NOW RECEIVED: VISITOR GOAL");
    addGoalVisitor();
  }

  bool startButton = digitalRead(BUTTON_START_STOP);
  bool resetButton = digitalRead(BUTTON_RESET);

  if (startButton == LOW && lastStartButton == HIGH) {
    toggleStartStop();
    delay(180);
  }

  if (!gameRunning) {
    if (resetButton == LOW && !resetWasPressed) {
      resetPressStart = millis();
      resetWasPressed = true;
    }

    if (resetButton == LOW && resetWasPressed) {
      if (millis() - resetPressStart >= RESET_HOLD_TIME) {
        resetGame();
        resetWasPressed = false;
        delay(300);
      }
    }

    if (resetButton == HIGH) {
      resetWasPressed = false;
    }
  }

  if (gameRunning && remainingTime > 0) {
    if (millis() - lastTimerUpdate >= 1000) {
      lastTimerUpdate = millis();
      remainingTime--;

      if (remainingTime == 10) {
        setLedMode(LED_LAST_SECONDS_RED_BLINK);
      }

      if (remainingTime == 0) {
        finishGame();
      }

      updateDisplay();
    }
  }

  if (showingGoal && millis() - goalMessageStart >= GOAL_MESSAGE_TIME) {
    showingGoal = false;
    updateDisplay();
  }

  updateLeds();

  lastStartButton = startButton;
  lastResetButton = resetButton;
}

English

Write a complete Arduino program for a PinSocc Ball scoreboard using ESP32, with WiFi.h, WebServer.h, esp_now.h, Wire.h, Adafruit_SSD1306.h, and Adafruit_NeoPixel.h. The system must include a 128x64 SSD1306 OLED over I2C on D4/D5, a 106-LED NeoPixel strip on GPIO18 divided into zones for bands, local goal, and visitor goal, two physical buttons on D0 and D1 for start/stop and reset, a web server running in Access Point mode with SSID "PinSoccBall" and password "12345678", and goal reception through ESP-NOW. The match must last 180 seconds, display score, time, and status on the OLED and web page, allow local/visitor goals from the web or ESP-NOW, show a GOAL message for 1.5 s, handle start/stop, allow reset only when the game is stopped by holding the reset button for 2 s, and automatically reset after the end animation. The LED strip must show green bands during the game, a green blinking start effect, a red warning during the last 10 s, a goal effect where the scoring goal zone turns green and the opposite zone turns red, and a final winner/tie animation. Use millis() for the timer and non-blocking effects, separate functions for display, LEDs, game logic, ESP-NOW, and web server, and include Serial debug messages.

Code · PinSoccB_LOCAL.ino Show code

// Code generated with the help of AI from the prompt described in the documentation; manually reviewed and adapted.

#include <WiFi.h>
#include <esp_now.h>
#include <ESP32Servo.h>

// -------------------- BOARD CONFIG --------------------
// This PCB is installed in the LOCAL goal.
// If the ball enters here, VISITOR scores.
#define BOARD_ID_LOCAL_GOAL 1

#define EVENT_GOAL_VISITOR 2

// MAIN MAC Address
uint8_t mainMAC[] = {0x58, 0xE6, 0xC5, 0x02, 0xF7, 0xC4};

// -------------------- PINS --------------------
#define IR_SENSOR_PIN D1

#define BUTTON_RIGHT D8
#define BUTTON_LEFT  D10

#define SERVO_RIGHT_PIN 17  // D7 = GPIO17
#define SERVO_LEFT_PIN  D2

// -------------------- SERVOS --------------------
Servo servoRight;
Servo servoLeft;

// Right servo: clockwise movement
const int RIGHT_REST_POS = 140;
const int RIGHT_HIT_POS  = 60;

// Left servo: inverse movement / anticlockwise
const int LEFT_REST_POS = 60;
const int LEFT_HIT_POS  = 140;

const unsigned long HIT_HOLD_TIME = 150;

// -------------------- IR SENSOR --------------------
const int GOAL_DETECTED_STATE = LOW;

bool lastIrState = HIGH;

unsigned long lastGoalTime = 0;
const unsigned long GOAL_DEBOUNCE_TIME = 300;

// -------------------- BUTTON STATES --------------------
bool lastRightButtonState = HIGH;
bool lastLeftButtonState  = HIGH;

bool rightFlipperActive = false;
bool leftFlipperActive  = false;

unsigned long rightHitStartTime = 0;
unsigned long leftHitStartTime  = 0;

// -------------------- ESP-NOW MESSAGE --------------------
typedef struct {
  uint8_t boardID;
  uint8_t eventType;
} EspNowMessage;

EspNowMessage messageToSend;

// -------------------- ESP-NOW CALLBACK --------------------
void onDataSent(const wifi_tx_info_t *info, esp_now_send_status_t status) {
  Serial.print("ESP-NOW send status: ");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "SUCCESS" : "FAIL");
}

// -------------------- ESP-NOW FUNCTIONS --------------------
void sendGoalVisitor() {
  messageToSend.boardID = BOARD_ID_LOCAL_GOAL;
  messageToSend.eventType = EVENT_GOAL_VISITOR;

  esp_err_t result = esp_now_send(mainMAC, (uint8_t *)&messageToSend, sizeof(messageToSend));

  if (result == ESP_OK) {
    Serial.println("ESP-NOW message sent: GOAL VISITOR");
  } else {
    Serial.println("ESP-NOW send error");
  }
}

void setupEspNow() {
  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }

  esp_now_register_send_cb(onDataSent);

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, mainMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add MAIN peer");
    return;
  }

  Serial.println("ESP-NOW ready");
}

// -------------------- SETUP --------------------
void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(IR_SENSOR_PIN, INPUT_PULLUP);

  pinMode(BUTTON_RIGHT, INPUT_PULLUP);
  pinMode(BUTTON_LEFT, INPUT_PULLUP);

  servoRight.attach(SERVO_RIGHT_PIN, 500, 2500);
  servoLeft.attach(SERVO_LEFT_PIN, 500, 2500);

  servoRight.write(RIGHT_REST_POS);
  servoLeft.write(LEFT_REST_POS);

  lastIrState = digitalRead(IR_SENSOR_PIN);

  setupEspNow();

  Serial.println("LOCAL GOAL PCB READY");
  Serial.println("IR goal here = VISITOR scores");
}

// -------------------- LOOP --------------------
void loop() {
  unsigned long now = millis();

  bool rightButtonState = digitalRead(BUTTON_RIGHT);
  bool leftButtonState  = digitalRead(BUTTON_LEFT);
  bool irState          = digitalRead(IR_SENSOR_PIN);

  // -------------------- IR GOAL DETECTION --------------------
  if (lastIrState != GOAL_DETECTED_STATE && irState == GOAL_DETECTED_STATE) {
    if (now - lastGoalTime >= GOAL_DEBOUNCE_TIME) {
      lastGoalTime = now;

      Serial.println("GOAL DETECTED IN LOCAL GOAL");
      Serial.println("VISITOR SCORES");

      sendGoalVisitor();
    }
  }

  lastIrState = irState;

  // -------------------- RIGHT BUTTON -> RIGHT SERVO --------------------
  if (lastRightButtonState == HIGH && rightButtonState == LOW && !rightFlipperActive) {
    Serial.println("RIGHT HIT");

    servoRight.write(RIGHT_HIT_POS);
    rightFlipperActive = true;
    rightHitStartTime = now;
  }

  // -------------------- LEFT BUTTON -> LEFT SERVO --------------------
  if (lastLeftButtonState == HIGH && leftButtonState == LOW && !leftFlipperActive) {
    Serial.println("LEFT HIT");

    servoLeft.write(LEFT_HIT_POS);
    leftFlipperActive = true;
    leftHitStartTime = now;
  }

  // -------------------- RIGHT RETURN --------------------
  if (rightFlipperActive && now - rightHitStartTime >= HIT_HOLD_TIME) {
    servoRight.write(RIGHT_REST_POS);
    rightFlipperActive = false;

    Serial.println("RIGHT RETURN");
  }

  // -------------------- LEFT RETURN --------------------
  if (leftFlipperActive && now - leftHitStartTime >= HIT_HOLD_TIME) {
    servoLeft.write(LEFT_REST_POS);
    leftFlipperActive = false;

    Serial.println("LEFT RETURN");
  }

  lastRightButtonState = rightButtonState;
  lastLeftButtonState = leftButtonState;
}

English

Write a complete Arduino program for a XIAO ESP32-C6 using WiFi.h, esp_now.h, and ESP32Servo.h. This PCB is installed in the local goal, so when the IR sensor detects the ball, it must send a visitor goal event via ESP-NOW to a main board whose MAC address is defined in the code. The system must include an IR sensor on D1 using INPUT_PULLUP, two buttons on D8 and D10 to control two flippers, and two servos: right servo on GPIO17 / D7 and left servo on D2. The right servo must move from 140° to 60° and return, while the left servo moves from 60° to 140° and returns, holding the hit position for 150 ms using non-blocking millis() logic. Goal detection must happen when the IR sensor goes LOW, with a 300 ms debounce, sending an ESP-NOW structure containing boardID and eventType. Include ESP-NOW setup in WIFI_STA mode, send callback registration, peer registration, Serial debug messages, and falling edge detection for the button presses.

Code · PinSoccB_VISITOR Show code

// Code generated with the help of AI from the prompt described in the documentation; manually reviewed and adapted.

#include <WiFi.h>
#include <esp_now.h>
#include <ESP32Servo.h>

// -------------------- BOARD CONFIG --------------------
// This PCB is installed in the VISITOR goal.
// If the ball enters here, LOCAL scores.
#define BOARD_ID_VISITOR_GOAL 2

#define EVENT_GOAL_LOCAL 1

// MAIN MAC Address
uint8_t mainMAC[] = {0x58, 0xE6, 0xC5, 0x02, 0xF7, 0xC4};

// -------------------- PINS --------------------
#define IR_SENSOR_PIN D1

#define BUTTON_RIGHT D8
#define BUTTON_LEFT  D10

#define SERVO_RIGHT_PIN 17  // D7 = GPIO17
#define SERVO_LEFT_PIN  D2

// -------------------- SERVOS --------------------
Servo servoRight;
Servo servoLeft;

// Right servo: clockwise movement
const int RIGHT_REST_POS = 130;
const int RIGHT_HIT_POS  = 70;

// Left servo: inverse movement / anticlockwise
const int LEFT_REST_POS = 70;
const int LEFT_HIT_POS  = 130;

const unsigned long HIT_HOLD_TIME = 180;

// -------------------- IR SENSOR --------------------
const int GOAL_DETECTED_STATE = LOW;

bool lastIrState = HIGH;

unsigned long lastGoalTime = 0;
const unsigned long GOAL_DEBOUNCE_TIME = 300;

// -------------------- BUTTON STATES --------------------
bool lastRightButtonState = HIGH;
bool lastLeftButtonState  = HIGH;

bool rightFlipperActive = false;
bool leftFlipperActive  = false;

unsigned long rightHitStartTime = 0;
unsigned long leftHitStartTime  = 0;

// -------------------- ESP-NOW MESSAGE --------------------
typedef struct {
  uint8_t boardID;
  uint8_t eventType;
} EspNowMessage;

EspNowMessage messageToSend;

// -------------------- ESP-NOW CALLBACK --------------------
void onDataSent(const wifi_tx_info_t *info, esp_now_send_status_t status) {
  Serial.print("ESP-NOW send status: ");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "SUCCESS" : "FAIL");
}

// -------------------- ESP-NOW FUNCTIONS --------------------
void sendGoalLocal() {
  messageToSend.boardID = BOARD_ID_VISITOR_GOAL;
  messageToSend.eventType = EVENT_GOAL_LOCAL;

  esp_err_t result = esp_now_send(mainMAC, (uint8_t *)&messageToSend, sizeof(messageToSend));

  if (result == ESP_OK) {
    Serial.println("ESP-NOW message sent: GOAL LOCAL");
  } else {
    Serial.println("ESP-NOW send error");
  }
}

void setupEspNow() {
  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }

  esp_now_register_send_cb(onDataSent);

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, mainMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add MAIN peer");
    return;
  }

  Serial.println("ESP-NOW ready");
}

// -------------------- SETUP --------------------
void setup() {
  Serial.begin(115200);
  delay(1000);

  pinMode(IR_SENSOR_PIN, INPUT_PULLUP);

  pinMode(BUTTON_RIGHT, INPUT_PULLUP);
  pinMode(BUTTON_LEFT, INPUT_PULLUP);

  servoRight.attach(SERVO_RIGHT_PIN, 500, 2500);
  servoLeft.attach(SERVO_LEFT_PIN, 500, 2500);

  servoRight.write(RIGHT_REST_POS);
  servoLeft.write(LEFT_REST_POS);

  lastIrState = digitalRead(IR_SENSOR_PIN);

  setupEspNow();

  Serial.println("VISITOR GOAL PCB READY");
  Serial.println("IR goal here = LOCAL scores");
}

// -------------------- LOOP --------------------
void loop() {
  unsigned long now = millis();

  bool rightButtonState = digitalRead(BUTTON_RIGHT);
  bool leftButtonState  = digitalRead(BUTTON_LEFT);
  bool irState          = digitalRead(IR_SENSOR_PIN);

  // -------------------- IR GOAL DETECTION --------------------
  if (lastIrState != GOAL_DETECTED_STATE && irState == GOAL_DETECTED_STATE) {
    if (now - lastGoalTime >= GOAL_DEBOUNCE_TIME) {
      lastGoalTime = now;

      Serial.println("GOAL DETECTED IN VISITOR GOAL");
      Serial.println("LOCAL SCORES");

      sendGoalLocal();
    }
  }

  lastIrState = irState;

  // -------------------- RIGHT BUTTON -> RIGHT SERVO --------------------
  if (lastRightButtonState == HIGH && rightButtonState == LOW && !rightFlipperActive) {
    Serial.println("RIGHT HIT");

    servoRight.write(RIGHT_HIT_POS);
    rightFlipperActive = true;
    rightHitStartTime = now;
  }

  // -------------------- LEFT BUTTON -> LEFT SERVO --------------------
  if (lastLeftButtonState == HIGH && leftButtonState == LOW && !leftFlipperActive) {
    Serial.println("LEFT HIT");

    servoLeft.write(LEFT_HIT_POS);
    leftFlipperActive = true;
    leftHitStartTime = now;
  }

  // -------------------- RIGHT RETURN --------------------
  if (rightFlipperActive && now - rightHitStartTime >= HIT_HOLD_TIME) {
    servoRight.write(RIGHT_REST_POS);
    rightFlipperActive = false;

    Serial.println("RIGHT RETURN");
  }

  // -------------------- LEFT RETURN --------------------
  if (leftFlipperActive && now - leftHitStartTime >= HIT_HOLD_TIME) {
    servoLeft.write(LEFT_REST_POS);
    leftFlipperActive = false;

    Serial.println("LEFT RETURN");
  }

  lastRightButtonState = rightButtonState;
  lastLeftButtonState = leftButtonState;
}

English

Write a complete Arduino program for a XIAO ESP32-C6 using WiFi.h, esp_now.h, and ESP32Servo.h. This PCB is installed in the visitor goal, so when the IR sensor detects the ball, it must send a local goal event via ESP-NOW to a main board whose MAC address is defined in the code. The system must include an IR sensor on D1 using INPUT_PULLUP, two buttons on D8 and D10 to control two flippers, and two servos: right servo on GPIO17 / D7 and left servo on D2. The right servo must move from 130° to 70° and return, while the left servo moves from 70° to 130° and returns, holding the hit position for 180 ms using non-blocking millis() logic. Goal detection must happen when the IR sensor goes LOW, with a 300 ms debounce, sending an ESP-NOW structure containing boardID and eventType. Include ESP-NOW setup in WIFI_STA mode, send callback registration, peer registration, Serial debug messages, and falling edge detection for the button presses.

Final assembly and installation

Down wood case

Once all the parts had been milled, I lightly sanded them to improve the finish and remove any small imperfections. With the pieces ready, it was time to assemble the lower cabinet.

Since the entire structure was designed as a press-fit system, all the parts could be joined together without the need for screws, glue, or any other fastening elements. Using a rubber mallet, I carefully fitted each piece into place, making sure that every joint was fully seated and aligned.

The use of dogbones in the internal corners also ensured that the parts fit together correctly despite the diameter limitations of the milling tool used during fabrication.

Once the assembly was completed, the result was a strong and rigid structure that would serve as the foundation for all the mechanical and electronic components of the project.

Upper wood case

The next assembly stage was building the upper cabinet, which forms the visible structure of the playing field. Just like the lower cabinet, all parts were designed using a press-fit system, eliminating the need for screws or adhesives.

This section consists of the four milled perimeter panels. Each panel includes an internal slot designed to hold the playing surface, which had previously been laser-cut and engraved from a bi-layer board.

To make the assembly process easier, I first joined the two long side panels and one of the short side panels. With the structure partially open, I was able to slide the playing surface into position through the slots until it was fully seated.

Once the playing surface was correctly aligned, I completed the assembly by installing the final side panel, closing the structure and securely holding the playing field in place.

Upper wood case assembly (video size: 0 Mb).

High quality video and 1x speed available on my YouTube channel ↗️.

Ramps Assembly

The next step was assembling the ramps responsible for guiding the ball back into the playing area. These parts were laser-cut from 3 mm MDF and designed following the same press-fit philosophy used throughout the project, making both assembly and maintenance straightforward.

The three ramps—the two side ramps and the central ramp—were assembled from several interlocking parts that fit together without the need for additional fastening elements. Once assembled, they were inserted into the lower cabinet.

Like the rest of the structure, the ramps were designed to fit directly into dedicated slots within the cabinet, remaining securely in place through friction alone. This resulted in a rigid and well-aligned assembly, ensuring the ball would follow the intended path during gameplay.

Corners

The four corners of the playing field were manufactured using 3D printing. Their purpose is not structural but rather to help redirect the ball toward the hand flipper area whenever it reaches the corners of the playfield.

Since these parts are not required to support any significant loads or mechanical stress, their installation was very straightforward. I fixed them in place using double-sided adhesive tape, which provides more than enough holding strength for normal gameplay.

Once installed, the corners blended seamlessly into the playing surface, helping the ball move more smoothly around the field and preventing situations where it could become trapped or lose momentum.

Corners installation (video size: 0 Mb).

Top cover

This was one of the most time-consuming and delicate parts of the assembly process. The top cover is made from 3 mm MDF and includes a laser-engraved pattern on its rear side that acts as a routing guide for the wiring.

The purpose of these engraved channels is to carry the two-wire power cable from the main PCB located in the center of the machine to the two goal-detection PCBs positioned at each end of the playing field. To secure the cable along its path, I used hot glue, which provided a simple and reliable fixing method without requiring additional mechanical fasteners.

Power cable (video size: 0 Mb).

Once the power wiring was in place, I installed the four LED strip sections in their designated positions and connected them together to create a single lighting system.

Special attention had to be paid to the cable exits from each LED section, as they needed to align with the recessed areas designed into the upper wooden structure. This ensured that the cover would sit correctly during the final assembly.

To keep everything organized throughout the process, I used painter's tape to temporarily secure the interconnection wires between LED strip sections and to identify each segment according to its function within the system, distinguishing between the side bands and the goal areas. This made the final wiring and system integration much easier and helped prevent connection mistakes.

Servos

The servos were installed using the custom 3D-printed brackets specifically designed for this purpose. These supports allow the motors to be mounted securely while maintaining accurate positioning during gameplay.

The installation process consists of positioning each servo beneath the playing field and carefully adjusting its height until the servo spline protrudes through the corresponding opening in the playfield. Achieving the correct position is important to ensure proper alignment with the hand flipper mechanism.

Once the desired height is reached, the bracket is secured to the wooden structure using screws, leaving the servo firmly mounted and correctly aligned with the game mechanism.

Finally, the servo cable is routed through its dedicated opening and into the interior of the machine, ready to be connected to the control electronics during the final integration stage.

Electronic Cases (main and goals)

The next step was installing the three 3D-printed enclosures that house all the electronics of the project. These cases contain the PCBs, control buttons, connectors and, in the case of the main enclosure, the OLED display.

Installing each enclosure is straightforward because both the wooden structure and the cases themselves include a rectangular cable pass-through designed to align during assembly. Once properly positioned, each enclosure is secured to the wooden structure using screws.

For the Main Case, I first routed the two cables that connect to the Goal Boxes/Cases. I then installed the OLED display and the control buttons in their dedicated openings. Once all external components were in place, I connected them to the main PCB and secured the board to the integrated mounting points inside the enclosure.

Goal case detail — Main case detail (size: 0 Kb -click to enlarge-).

For each Goal Case, I routed the cables coming from the two servos and guided them to the upper electronics area. I also installed the control buttons and the power cable arriving from the Main Case. Next, I mounted the infrared sensor inside its dedicated holder and routed its cable toward the upper section of the enclosure.

With all components installed, I connected everything to the corresponding PCB and secured the board to the mounting supports integrated into the enclosure. This left all the electronics protected, organized, and ready for the final integration and testing stages.

Handflipper

The hand flippers are installed once the servos have been correctly mounted and aligned with the openings in the playing field.

Each hand flipper must be fitted onto the servo spline, ensuring that it is oriented in the correct operating position. It is recommended to verify the servo resting angle beforehand so that all flippers remain properly aligned when the system is in its idle state.

Once the correct position has been confirmed, the hand flipper is secured to the servo using the central screw supplied with the motor. This procedure must be repeated for all four game mechanisms.

After installation, it is advisable to perform a manual movement test to verify that the flippers can travel through their full operating range without interfering with the playing surface or any other mechanical components.

Ball exit box

The Ball Box is installed at the ball exit area located inside the lower cabinet. This 3D-printed component is responsible for collecting the ball at the end of its return path and positioning it correctly for the next launch.

It is important to verify that the Ball Box is correctly positioned relative to the ramp exits to ensure a smooth transition of the ball into the compartment.

Once installed, it is recommended to perform a simple test by rolling a ball through the return system and confirming that it reaches the Ball Box correctly, without any unwanted friction or blockage points.

Hingle

The final step of the mechanical assembly is the installation of the hinges that connect the upper cabinet to the lower cabinet. These hinges allow the playfield to be opened in a manner similar to a pinball machine, providing access to the interior for maintenance, adjustments, and repairs.

To install them, both sections of the structure must be properly aligned before securing the hinges with screws. Once mounted, it is advisable to verify that the cabinet opens and closes smoothly and that no mechanical interferences are present.

As an optional addition, front latches can be installed to keep the cabinet securely closed during operation. In my case, I added two metal latches on the front side of the machine to prevent accidental opening while playing or transporting the project.

With this step completed, the main mechanical assembly of the project is finished, leaving the machine ready for final testing and commissioning.

Future evolutions

The future evolution of PinSocc Ball is focused on turning the current prototype into a more connected, automated, and engaging game experience.

One possible improvement is an app and web platform where players could store match statistics, check previous results, manage users, and organize small championships or tournaments.

Another important evolution would be an automatic ball elevator system, using a worm gear mechanism to return the ball to the playing field without manual intervention.

The project could also include online rankings, additional game modes, and sound or haptic feedback to make the gameplay more immersive, competitive, and replayable.

License

CC BY-NC-SA 4.0: Attribution - NonCommercial - ShareAlike 4.0 International