ESP32 Arcade Project

Piggy Bank Slot Machine

Saving money is usually boring, so I wanted to turn it into a small arcade game. This project combines a piggy bank with a slot machine: every inserted coin gives one spin, small wins give extra spins, and the jackpot unlocks the money chamber.

The machine is built around an ESP32, a coin sensor, a spin button, a TFT display, and a servo-controlled gate. The main idea is simple: coins go in, the game starts, and the chamber only opens when the machine hits 777.

DIY piggy bank slot machine with ESP32, display, coin slot and servo gate

1. Project Idea

The goal of this project was to make saving coins more fun. Instead of just dropping money into a normal piggy bank, every coin gives the player one spin on a small slot machine. The player can win extra spins, but the money chamber stays locked until the jackpot result appears.

Coin insertedOne coin is detected and one available spin is added.

Spin buttonThe button starts the slot machine when at least one spin credit is available.

Small winsWinning combinations give extra spins, but do not open the money chamber.

JackpotWhen the result is 777, the ESP32 opens the gate to the money chamber.

2. Required Parts

For the first working prototype, I used the following parts:

ControllerESP32 development board

DisplayTFT display controlled with the TFT_eSPI library

Coin sensorTCST2103 optical light gate or similar IR slot sensor

ButtonMomentary push button for starting a spin

Gate motorSmall servo motor for locking and unlocking the money chamber

Resistors220 Ω for the IR LED and 10 kΩ for the sensor signal circuit

Power5 V supply for the ESP32/display setup and a suitable supply for the servo

Housing3D printed two-chamber enclosure with coin slot and front panel

Important: A servo should not be powered directly from a weak ESP32 3.3 V pin. Use a suitable 5 V supply for the servo and connect the ESP32 ground and servo supply ground together.

3. System Overview

The machine has three main jobs: detect an inserted coin, detect the spin button, and control the gate. The ESP32 connects these parts together and decides when the player is allowed to spin or open the money chamber.

Coin passes through the optical sensor

ESP32 adds one spin credit

Button press starts the slot machine animation

ESP32 checks the result and calculates the payout

Only 777 activates the servo gate and opens the money chamber

4. Coin Detection with an Optical Sensor

The most important part of the project is the coin detection. I used a TCST2103 optical switch. This component works like a small light gate. One side contains an infrared LED, and the other side contains a phototransistor.

If there is no coin inside the slot, the infrared light reaches the phototransistor. When a coin falls through the slot, it blocks the light. The ESP32 reads this change as the coin signal.

In the prototype code below, the coin input is configured as an active-HIGH signal: the sensor reads LOW when the slot is free and HIGH while the coin blocks the light gate. This matches the uploaded prototype firmware.

Condition	Sensor state in this prototype	ESP32 interpretation
No coin in the light gate	LOW / free	No new coin counted
Coin blocks the light gate	HIGH / blocked	One coin is accepted and one spin credit is added

Wiring note: The video explanation and the prototype code must use the same signal logic. If your sensor circuit uses a pull-up version where the signal is inverted, change COIN_SENSOR_ACTIVE_STATE in the code or invert the condition in readCoinSensorActive().

5. Spin Button

The spin button is wired from an ESP32 input pin to ground. In the firmware, the ESP32 internal pull-up resistor is enabled. That means the pin is normally HIGH. When the button is pressed, the pin is pulled to ground and becomes LOW.

The firmware detects this falling edge and starts the slot machine only if a spin credit is available. A short debounce time prevents one physical button press from being counted multiple times.

#define SPIN_BUTTON_PIN          33
#define SPIN_BUTTON_DEBOUNCE_MS  120

pinMode(SPIN_BUTTON_PIN, INPUT_PULLUP);

6. Servo Gate for the Money Chamber

The housing uses a two-chamber design. One side contains the electronics and the servo. The other side is the money chamber. The servo acts as a small gate that blocks access to the coins.

At startup, the servo is moved into the closed position. When the jackpot condition is reached, the ESP32 moves the servo to the open position for a short time and then closes it again.

#define GATE_SERVO_PIN           27
#define GATE_SERVO_CLOSED_ANGLE  0
#define GATE_SERVO_OPEN_ANGLE    90
#define GATE_SERVO_OPEN_TIME_MS  2500

7. Slot Machine Logic

The game logic is intentionally simple. Every spin creates three symbols on the display. The middle payline is the main result. If the symbols form a winning combination, the player gets extra spins. Only the jackpot opens the gate.

Result	Reward	Gate opens?
777	Jackpot	Yes
Other strong winning combinations	Extra spin credits	No
Small winning combinations	Small number of extra spins	No
No win	No extra credits	No

Design idea: Small wins keep the game fun, but they do not unlock the stored money. The real reward is only triggered by the jackpot result.

8. Prototype Electronics Test

Before putting everything into the housing, I tested the electronics on the bench. For the first prototype setup, the ESP32 was mainly used to provide power, read the coin signal, read the button input, drive the display, and control the servo gate.

I also reused my small hardware monitor to directly check whether the coin recognition and button input were working correctly. This made debugging much easier before the full mechanical assembly.

9. Housing and Mechanical Assembly

After the electronics test, I started assembling the full prototype. The housing uses two chambers: the electronics chamber and the money chamber. The coin sensor sits directly below the coin slot, so every inserted coin must pass through the light gate before it drops into the storage area.

For this first version, I soldered the resistors and wires directly to the sensor leads instead of using a separate PCB. This is not the cleanest final solution, but it gives more freedom for cable routing inside a tight 3D printed housing.

Some parts of the 3D print were joined by carefully melting the PLA edges with an old soldering iron. This works for rough prototypes, but it should be done carefully because the visible surfaces can deform easily.

Prototype warning: Melting PLA with a soldering iron is useful for quick tests, but it is not a clean final assembly method. Work with good ventilation and avoid touching hot plastic or fumes.

10. Display Rotation Issue

During assembly, I noticed that the display was mounted upside down. Luckily, this was only a software problem. The display output can be rotated by 180 degrees in the firmware, so the hardware did not need to be rebuilt.

// Example for TFT_eSPI display rotation
// Use the value that matches your physical display orientation.
tft.setRotation(2);

11. Final Prototype Result

This is the first working prototype of the piggy bank slot machine. A coin gives one spin, the button starts the slot machine, small wins give extra spins, and the jackpot result 777 opens the money chamber.

The prototype still needs improvements, especially in the housing design, cable management, and gate mechanism. But the basic idea works: the ESP32 can detect coins, manage spin credits, run the slot machine logic, and unlock the chamber only after a jackpot.

In the next version, I want to make the design cleaner, improve the gate mechanism, and build a more arcade-like front panel.

Final working prototype of the ESP32 piggy bank slot machine

12. Pin Overview

These are the most important pins used in the uploaded prototype code. Change them if your wiring is different.

Function	ESP32 Pin	Notes
Coin sensor input	GPIO34	Input-only pin. The code expects an external signal circuit and active-HIGH coin detection.
Constant HIGH output for sensor circuit	GPIO32	Used as a permanent HIGH signal in the prototype wiring.
Spin button	GPIO33	Uses internal pull-up. Button connects the pin to GND when pressed.
Servo signal	GPIO27	Servo signal only. Use a suitable power supply for the servo.
TFT enable / backlight	GPIO17	Turns the display enable/backlight signal on.
Touch CS / IRQ	GPIO26 / GPIO25	Included for future use, but not used as touch buttons in this prototype.

Full Prototype Code: piggybank.ino

This is the full Arduino prototype code used for the ESP32 piggy bank slot machine. Create a new Arduino IDE project, paste the code into the main .ino file, install the required libraries, and adjust the pin configuration if your wiring is different.

piggybank.ino

#include <Arduino.h>
#include <SPI.h>
#include <Wire.h>
#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>
#include <ESP32Servo.h>

// ————————————————————
// Display
// ————————————————————
TFT_eSPI tft = TFT_eSPI();

// ————————————————————
// Touch configuration
// Kept for future use, but no touch buttons are used in this version.
// ————————————————————
#define TOUCH_CS   26
#define TOUCH_IRQ  25
SPIClass touchSPI(HSPI);
XPT2046_Touchscreen ts(TOUCH_CS, TOUCH_IRQ);

// ————————————————————
// Display enable / backlight
// ————————————————————
#define TFT_ENABLE_PIN 17
#define TFT_ENABLE_ON  HIGH

// ————————————————————
// Coin sensor
// GPIO34 is input-only on the ESP32. Use an external pulldown.
// Sensor output: LOW when free, HIGH / 3.3 V while blocked by a coin.
// GPIO32 is used as a constant HIGH output, for example to feed
// the sensor side that needs a permanent 3.3 V HIGH signal.
// ————————————————————
#define USE_COIN_SENSOR 1
#define COIN_SENSOR_PIN             34
#define COIN_SENSOR_HIGH_PIN        32
#define COIN_SENSOR_ACTIVE_STATE    HIGH

#define COIN_INTERRUPT_LOCKOUT_MS  5     // ISR noise filter only
#define COIN_COUNT_LOCKOUT_MS      350   // prevents one coin from being counted twice
#define COIN_RELEASE_STABLE_MS     60    // sensor must be free this long before re-arming
#define COIN_DEBUG_PRINT_MS        1000

// ————————————————————
// Start button with internal pull-up
// Wiring: GPIO33 -> button -> GND
// ————————————————————
#define SPIN_BUTTON_PIN          33
#define SPIN_BUTTON_DEBOUNCE_MS  120

// ————————————————————
// Jackpot gate servo
// Servo signal: GPIO27 -> servo signal wire
// Servo power : external 5 V supply recommended
// Important   : ESP32 GND and servo supply GND must be connected together
// ————————————————————
#define GATE_SERVO_PIN           27
#define GATE_SERVO_CLOSED_ANGLE  0
#define GATE_SERVO_OPEN_ANGLE    90
#define GATE_SERVO_OPEN_TIME_MS  2500
#define GATE_SERVO_MIN_US        500
#define GATE_SERVO_MAX_US        2400

// ————————————————————
// Game settings
// ————————————————————
#define START_CREDITS 0
#define SPIN_COST     1

#define REEL_COUNT    3
#define ROW_COUNT     3
#define SYMBOL_COUNT  6

#define REEL_SPEED_MS 75
#define SPIN_ANIM_MS  90

// ————————————————————
// Slot symbols
// ————————————————————
enum SlotSymbol {
  SYMBOL_CHERRY = 0,
  SYMBOL_LEMON,
  SYMBOL_SEVEN,
  SYMBOL_BAR,
  SYMBOL_BELL,
  SYMBOL_DIAMOND
};

enum GameState {
  STATE_IDLE,
  STATE_SPINNING,
  STATE_RESULT
};

enum WinLine {
  WIN_NONE = 0,
  WIN_TOP,
  WIN_MIDDLE,
  WIN_BOTTOM,
  WIN_DIAG_DOWN,
  WIN_DIAG_UP
};

// ————————————————————
// Globals
// ————————————————————
GameState gameState = STATE_IDLE;
WinLine activeWinLine = WIN_NONE;

int credits = START_CREDITS;
int totalCoinsSaved = 0;

int reelSymbols[REEL_COUNT][ROW_COUNT];
int finalSymbols[REEL_COUNT][ROW_COUNT];
bool reelStopped[REEL_COUNT] = { false, false, false };

unsigned long spinStartTime = 0;
unsigned long lastReelUpdateTime = 0;
unsigned long lastSpinFxTime = 0;
uint8_t spinFxStep = 0;

const unsigned long reelStopTime[REEL_COUNT] = {
  900, 1400, 1900
};

String messageText = “Insert coin”;

bool gateClosePending = false;
unsigned long gateOpenedTime = 0;

Servo gateServo;

#if USE_COIN_SENSOR
volatile bool coinPulseDetected = false;
volatile unsigned long lastCoinInterruptUs = 0;
#endif

// Layout
int screenW, screenH;
int headerH;
int gridX, gridY;
int cellSize;
int cellGap;
int gridW, gridH;
int messageY, messageH;
int infoY, infoH;

// Side decorative node positions
const int NODE_COUNT = 4;
int leftNodeY[NODE_COUNT];
int rightNodeY[NODE_COUNT];

// ————————————————————
// Function prototypes
// ————————————————————
void setupLayout();
void initReels();

void drawMainScreen();
void drawBackground();
uint16_t bgColorAtY(int y);
void fillBgRect(int x, int y, int w, int h);

void drawElectroDecorStatic();
void drawElectroDecorAnimated(bool spinning);
void drawHeaderAnimated(bool spinning);
void drawStatusLEDs(uint8_t step, bool spinning);

void drawSlotFrame();
void drawReels();
void drawColumn(int col, bool highlight);
void drawSingleCell(int col, int row, int symbol, bool highlight);
void drawSymbol(int symbol, int x, int y, int w, int h);
void drawCenterPaylineAnimated(bool spinning);
void drawWinLine(WinLine line);
void drawSpinIndicators(uint8_t step);

void drawMessage(const String &msg);
void drawAnimatedSpinningMessage(uint8_t step);
void drawInfoBar();
void drawCenteredText(const String &text, int x, int y, int size, uint16_t color, uint16_t bg);

void startSpin();
void updateSpin();
void finishSpin();
void addCoin();
int randomSymbol();
int payoutForThree(int a, int b, int c);
int evaluatePayout(String &resultMessage);
bool is777JackpotWin();
String lineName(WinLine line);

void setupGateServo();
void openGateServo();
void closeGateServo();
void updateGateServo();

void IRAM_ATTR coinSensorISR();
void updateCoinSensor();
void updateSpinButton();
bool readCoinSensorActive();
void updateSpinAnimation();

int cellX(int col);
int cellY(int row);

// ————————————————————
// Setup
// ————————————————————
void setup() {
  Serial.begin(115200);
  delay(500);

  Serial.println();
  Serial.println(“ESP32 Elektro Spin starting…”);

  pinMode(TFT_ENABLE_PIN, OUTPUT);
  digitalWrite(TFT_ENABLE_PIN, TFT_ENABLE_ON);

  pinMode(SPIN_BUTTON_PIN, INPUT_PULLUP);

  // Force the gate servo to the safe closed position during startup.
  setupGateServo();

#if USE_COIN_SENSOR
  pinMode(COIN_SENSOR_HIGH_PIN, OUTPUT);
  digitalWrite(COIN_SENSOR_HIGH_PIN, HIGH);

  // GPIO34 has no internal pull-up/pull-down.
  // The pulldown must be external. Sensor signal is active HIGH.
  pinMode(COIN_SENSOR_PIN, INPUT);

  if (COIN_SENSOR_ACTIVE_STATE == HIGH) {
    attachInterrupt(digitalPinToInterrupt(COIN_SENSOR_PIN), coinSensorISR, RISING);
  } else {
    attachInterrupt(digitalPinToInterrupt(COIN_SENSOR_PIN), coinSensorISR, FALLING);
  }
#endif

  // Display
  tft.init();
  tft.setRotation(0);
  tft.fillScreen(TFT_BLACK);

  screenW = tft.width();
  screenH = tft.height();

  setupLayout();

  // Touch init kept for future extensions.
  touchSPI.begin(14, 12, 13, TOUCH_CS);  // SCK, MISO, MOSI, CS
  ts.begin(touchSPI);
  ts.setRotation(0);

  randomSeed(micros());

  initReels();
  drawMainScreen();

  Serial.println(“Ready”);
  Serial.println(“Spin button: GPIO33 -> button -> GND”);
  Serial.println(“Coin sensor : GPIO34 digital input, external pulldown, active HIGH”);
  Serial.println(“GPIO32      : constant HIGH output”);
  Serial.println(“Gate servo  : GPIO27 signal, starts at 0 degrees”);
}

// ————————————————————
// Main loop
// ————————————————————
void loop() {
  updateCoinSensor();
  updateSpinButton();
  updateGateServo();

  if (gameState == STATE_SPINNING) {
    updateSpin();

    // Important:
    // updateSpin() may finish the spin and change gameState to STATE_RESULT.
    // Therefore only draw the spin animation if it is still spinning.
    if (gameState == STATE_SPINNING) {
      updateSpinAnimation();
    }
  }
}

// ————————————————————
// Layout
// ————————————————————
void setupLayout() {
  screenW = tft.width();
  screenH = tft.height();

  cellGap = 4;
  headerH = 42;
  messageH = 24;
  infoH = 28;

  int gridAreaTop = headerH + 8;
  int infoBottomMargin = 6;

  infoY = screenH – infoH – infoBottomMargin;
  messageY = infoY – messageH – 5;

  int gridAreaBottom = messageY – 8;
  int availableH = gridAreaBottom – gridAreaTop;
  int availableW = screenW – 26;

  int maxCellByH = (availableH – 2 * cellGap) / 3;
  int maxCellByW = (availableW – 2 * cellGap) / 3;

  cellSize = min(maxCellByH, maxCellByW);
  cellSize = constrain(cellSize, 38, 72);

  gridW = 3 * cellSize + 2 * cellGap;
  gridH = 3 * cellSize + 2 * cellGap;

  gridX = (screenW – gridW) / 2;
  gridY = gridAreaTop + (availableH – gridH) / 2;

  leftNodeY[0] = gridY + 6;
  leftNodeY[1] = gridY + gridH / 3;
  leftNodeY[2] = gridY + (2 * gridH) / 3;
  leftNodeY[3] = gridY + gridH – 6;

  for (int i = 0; i < NODE_COUNT; i++) {
    rightNodeY[i] = leftNodeY[i];
  }
}

// ————————————————————
// Helpers
// ————————————————————
int cellX(int col) {
  return gridX + col * (cellSize + cellGap);
}

int cellY(int row) {
  return gridY + row * (cellSize + cellGap);
}

void drawCenteredText(const String &text, int x, int y, int size,
                      uint16_t color, uint16_t bg) {
  tft.setTextDatum(MC_DATUM);
  tft.setTextSize(size);
  tft.setTextColor(color, bg);
  tft.drawString(text, x, y);
  tft.setTextSize(1);
}

uint16_t bgColorAtY(int y) {
  y = constrain(y, 0, screenH – 1);
  float t = (float)y / (float)(screenH – 1);

  uint8_t r = 8  + (int)((3  – 8)  * t);
  uint8_t g = 20 + (int)((8  – 20) * t);
  uint8_t b = 40 + (int)((18 – 40) * t);

  return tft.color565(r, g, b);
}

void fillBgRect(int x, int y, int w, int h) {
  if (w <= 0 || h <= 0) return;

  x = constrain(x, 0, screenW – 1);
  y = constrain(y, 0, screenH – 1);
  w = min(w, screenW – x);
  h = min(h, screenH – y);

  for (int yy = y; yy < y + h; yy++) {
    tft.drawFastHLine(x, yy, w, bgColorAtY(yy));
  }
}

// ————————————————————
// Visual theme
// ————————————————————
void drawBackground() {
  for (int y = 0; y < screenH; y++) {
    tft.drawFastHLine(0, y, screenW, bgColorAtY(y));
  }
}

void drawElectroDecorStatic() {
  uint16_t trace1 = tft.color565(0, 130, 160);
  uint16_t trace2 = tft.color565(0, 100, 80);
  uint16_t nodeDim = tft.color565(20, 90, 90);

  int lx = 10;
  tft.drawLine(lx, gridY – 6, lx, infoY + infoH, trace1);
  tft.drawLine(lx, leftNodeY[0], 26, leftNodeY[0], trace1);
  tft.drawLine(lx, leftNodeY[1], 22, leftNodeY[1], trace2);
  tft.drawLine(lx, leftNodeY[2], 28, leftNodeY[2], trace1);
  tft.drawLine(lx, leftNodeY[3], 24, leftNodeY[3], trace2);

  for (int i = 0; i < NODE_COUNT; i++) {
    tft.fillCircle(lx, leftNodeY[i], 2, nodeDim);
  }
  tft.fillCircle(26, leftNodeY[0], 2, nodeDim);
  tft.fillCircle(22, leftNodeY[1], 2, nodeDim);
  tft.fillCircle(28, leftNodeY[2], 2, nodeDim);
  tft.fillCircle(24, leftNodeY[3], 2, nodeDim);

  int rx = screenW – 10;
  tft.drawLine(rx, gridY – 6, rx, infoY + infoH, trace1);
  tft.drawLine(rx – 16, rightNodeY[0], rx, rightNodeY[0], trace2);
  tft.drawLine(rx – 22, rightNodeY[1], rx, rightNodeY[1], trace1);
  tft.drawLine(rx – 18, rightNodeY[2], rx, rightNodeY[2], trace2);
  tft.drawLine(rx – 24, rightNodeY[3], rx, rightNodeY[3], trace1);

  for (int i = 0; i < NODE_COUNT; i++) {
    tft.fillCircle(rx, rightNodeY[i], 2, nodeDim);
  }
  tft.fillCircle(rx – 16, rightNodeY[0], 2, nodeDim);
  tft.fillCircle(rx – 22, rightNodeY[1], 2, nodeDim);
  tft.fillCircle(rx – 18, rightNodeY[2], 2, nodeDim);
  tft.fillCircle(rx – 24, rightNodeY[3], 2, nodeDim);
}

void drawElectroDecorAnimated(bool spinning) {
  if (!spinning) return;

  uint16_t nodeDim = tft.color565(20, 90, 90);
  uint16_t nodeBright1 = tft.color565(80, 255, 230);
  uint16_t nodeBright2 = tft.color565(0, 220, 255);

  int activeA = spinFxStep % NODE_COUNT;
  int activeB = (spinFxStep + 2) % NODE_COUNT;

  int lx = 10;
  int rx = screenW – 10;

  for (int i = 0; i < NODE_COUNT; i++) {
    tft.fillCircle(lx, leftNodeY[i], 2, nodeDim);
    tft.fillCircle(rx, rightNodeY[i], 2, nodeDim);
  }

  tft.fillCircle(lx, leftNodeY[activeA], 3, nodeBright1);
  tft.fillCircle(rx, rightNodeY[activeA], 3, nodeBright1);

  tft.fillCircle(lx, leftNodeY[activeB], 2, nodeBright2);
  tft.fillCircle(rx, rightNodeY[activeB], 2, nodeBright2);
}

void drawStatusLEDs(uint8_t step, bool spinning) {
  uint16_t panel = tft.color565(5, 28, 55);

  tft.fillCircle(18, 16, 5, panel);
  tft.fillCircle(screenW – 18, 16, 5, panel);

  uint16_t leftColor = TFT_RED;
  uint16_t rightColor = TFT_GREEN;

  if (spinning) {
    leftColor = (step % 2 == 0) ? TFT_RED : TFT_ORANGE;
    rightColor = (step % 2 == 0) ? TFT_GREEN : TFT_YELLOW;
  }

  tft.fillCircle(18, 16, 3, leftColor);
  tft.fillCircle(screenW – 18, 16, 3, rightColor);
}

void drawHeaderAnimated(bool spinning) {
  uint16_t panel = tft.color565(5, 28, 55);
  uint16_t border = spinning ? tft.color565(0, 255, 220) : tft.color565(0, 220, 255);
  uint16_t titleColor = spinning ? tft.color565(120, 255, 255) : tft.color565(180, 255, 255);

  tft.fillRoundRect(8, 6, screenW – 16, headerH – 10, 8, panel);
  tft.drawRoundRect(8, 6, screenW – 16, headerH – 10, 8, border);

  drawStatusLEDs(spinFxStep, spinning);
  drawCenteredText(“ELEKTRO SPIN”, screenW / 2, 21, 3, titleColor, panel);
}

// ————————————————————
// Slot frame and reel drawing
// ————————————————————
void drawSlotFrame() {
  uint16_t outer = tft.color565(0, 220, 255);
  uint16_t inner = tft.color565(8, 16, 28);
  uint16_t glow  = tft.color565(0, 120, 90);

  int pad = 8;
  tft.fillRoundRect(gridX – pad, gridY – pad, gridW + 2 * pad, gridH + 2 * pad, 10, inner);
  tft.drawRoundRect(gridX – pad, gridY – pad, gridW + 2 * pad, gridH + 2 * pad, 10, outer);
  tft.drawRoundRect(gridX – pad + 3, gridY – pad + 3, gridW + 2 * pad – 6, gridH + 2 * pad – 6, 8, glow);

  for (int i = 0; i < 3; i++) {
    int yy = gridY + 10 + i * ((gridH – 20) / 2);
    tft.drawLine(gridX – pad – 6, yy, gridX – pad, yy, outer);
    tft.drawLine(gridX + gridW + pad, yy, gridX + gridW + pad + 6, yy, outer);
  }
}

void drawSymbol(int symbol, int x, int y, int w, int h) {
  int cx = x + w / 2;
  int cy = y + h / 2;
  int s = min(w, h);

  switch (symbol) {
    case SYMBOL_CHERRY: {
      int r = max(4, s / 7);
      tft.drawLine(cx, cy – r, cx + r, cy – 3 * r, TFT_GREEN);
      tft.drawLine(cx – r, cy – r, cx + r, cy – 3 * r, TFT_GREEN);
      tft.fillCircle(cx – r, cy + r, r, TFT_RED);
      tft.fillCircle(cx + r, cy + r, r, TFT_RED);
      tft.drawCircle(cx – r, cy + r, r, tft.color565(100, 0, 0));
      tft.drawCircle(cx + r, cy + r, r, tft.color565(100, 0, 0));
      break;
    }

    case SYMBOL_LEMON: {
      int rw = max(8, s / 3);
      int rh = max(5, s / 5);
      tft.fillRoundRect(cx – rw, cy – rh, 2 * rw, 2 * rh, rh, TFT_YELLOW);
      tft.drawRoundRect(cx – rw, cy – rh, 2 * rw, 2 * rh, rh, TFT_ORANGE);
      int txtSize = (s >= 44) ? 2 : 1;
      drawCenteredText(“L”, cx, cy, txtSize, TFT_BLACK, TFT_YELLOW);
      break;
    }

    case SYMBOL_SEVEN: {
      int txtSize = (s >= 56) ? 4 : (s >= 42 ? 3 : 2);
      drawCenteredText(“7”, cx, cy, txtSize, TFT_RED, TFT_WHITE);
      break;
    }

    case SYMBOL_BAR: {
      int bw = w – 10;
      int bh = max(12, h / 3);
      tft.fillRoundRect(cx – bw / 2, cy – bh / 2, bw, bh, 4, TFT_BLACK);
      tft.drawRoundRect(cx – bw / 2, cy – bh / 2, bw, bh, 4, TFT_YELLOW);
      int txtSize = (bw >= 54) ? 2 : 1;
      drawCenteredText(“BAR”, cx, cy, txtSize, TFT_WHITE, TFT_BLACK);
      break;
    }

    case SYMBOL_BELL: {
      int bw = max(18, s / 2);
      int bh = max(18, s / 2);
      uint16_t brown = tft.color565(120, 60, 0);
      tft.fillRoundRect(cx – bw / 2, cy – bh / 2, bw, bh, 8, TFT_ORANGE);
      tft.fillRect(cx – bw / 2 – 3, cy + bh / 4, bw + 6, max(4, bh / 5), TFT_ORANGE);
      tft.fillCircle(cx, cy + bh / 2, 3, TFT_DARKGREY);
      tft.drawRoundRect(cx – bw / 2, cy – bh / 2, bw, bh, 8, brown);
      int txtSize = (s >= 44) ? 2 : 1;
      drawCenteredText(“B”, cx, cy, txtSize, TFT_BLACK, TFT_ORANGE);
      break;
    }

    case SYMBOL_DIAMOND: {
      int dh = max(10, s / 2);
      int dw = max(8, s / 3);
      uint16_t lightBlue = tft.color565(80, 210, 255);
      tft.fillTriangle(cx, cy – dh, cx – dw, cy, cx + dw, cy, TFT_CYAN);
      tft.fillTriangle(cx, cy + dh, cx – dw, cy, cx + dw, cy, lightBlue);
      tft.drawLine(cx, cy – dh, cx – dw, cy, TFT_BLUE);
      tft.drawLine(cx, cy – dh, cx + dw, cy, TFT_BLUE);
      tft.drawLine(cx – dw, cy, cx, cy + dh, TFT_BLUE);
      tft.drawLine(cx + dw, cy, cx, cy + dh, TFT_BLUE);
      break;
    }
  }
}

void drawSingleCell(int col, int row, int symbol, bool highlight) {
  int x = cellX(col);
  int y = cellY(row);

  uint16_t cellBg = tft.color565(244, 246, 248);
  uint16_t border = highlight ? TFT_YELLOW : tft.color565(0, 160, 180);

  tft.fillRoundRect(x, y, cellSize, cellSize, 6, cellBg);
  tft.drawRoundRect(x, y, cellSize, cellSize, 6, border);

  drawSymbol(symbol, x + 2, y + 2, cellSize – 4, cellSize – 4);
}

void drawColumn(int col, bool highlight) {
  for (int row = 0; row < ROW_COUNT; row++) {
    drawSingleCell(col, row, reelSymbols[col][row], highlight);
  }
}

void drawCenterPaylineAnimated(bool spinning) {
  int y = cellY(1) + cellSize / 2;
  uint16_t color = TFT_RED;

  if (spinning) {
    color = (spinFxStep % 2 == 0) ? TFT_RED : TFT_YELLOW;
  }

  tft.drawFastHLine(gridX – 4, y, gridW + 8, color);
  tft.drawFastHLine(gridX – 4, y – 1, gridW + 8, tft.color565(120, 0, 0));
}

void drawReels() {
  drawSlotFrame();

  for (int col = 0; col < REEL_COUNT; col++) {
    drawColumn(col, false);
  }

  drawCenterPaylineAnimated(false);
}

void drawWinLine(WinLine line) {
  if (line == WIN_NONE) return;

  int x0, y0, x1, y1;

  if (line == WIN_TOP) {
    x0 = cellX(0) + 4;
    y0 = cellY(0) + cellSize / 2;
    x1 = cellX(2) + cellSize – 4;
    y1 = y0;
  } else if (line == WIN_MIDDLE) {
    x0 = cellX(0) + 4;
    y0 = cellY(1) + cellSize / 2;
    x1 = cellX(2) + cellSize – 4;
    y1 = y0;
  } else if (line == WIN_BOTTOM) {
    x0 = cellX(0) + 4;
    y0 = cellY(2) + cellSize / 2;
    x1 = cellX(2) + cellSize – 4;
    y1 = y0;
  } else if (line == WIN_DIAG_DOWN) {
    x0 = cellX(0) + cellSize / 2;
    y0 = cellY(0) + cellSize / 2;
    x1 = cellX(2) + cellSize / 2;
    y1 = cellY(2) + cellSize / 2;
  } else {
    x0 = cellX(0) + cellSize / 2;
    y0 = cellY(2) + cellSize / 2;
    x1 = cellX(2) + cellSize / 2;
    y1 = cellY(0) + cellSize / 2;
  }

  tft.drawLine(x0, y0, x1, y1, TFT_YELLOW);
  tft.drawLine(x0, y0 – 1, x1, y1 – 1, TFT_YELLOW);
  tft.drawLine(x0, y0 + 1, x1, y1 + 1, TFT_ORANGE);
}

void drawSpinIndicators(uint8_t step) {
  fillBgRect(gridX – 22, gridY – 4, 14, gridH + 8);
  fillBgRect(gridX + gridW + 8, gridY – 4, 14, gridH + 8);

  uint16_t c1 = (step % 2 == 0) ? TFT_CYAN : TFT_YELLOW;
  uint16_t c2 = (step % 2 == 0) ? TFT_GREEN : TFT_ORANGE;

  int offset = (step % 3) * (cellSize / 3);

  for (int i = 0; i < 3; i++) {
    int yy = gridY + 10 + i * (gridH / 3) + offset / 3;
    yy = constrain(yy, gridY + 8, gridY + gridH – 12);

    tft.fillTriangle(gridX – 18, yy, gridX – 10, yy – 4, gridX – 10, yy + 4, c1);
    tft.fillTriangle(gridX + gridW + 18, yy, gridX + gridW + 10, yy – 4, gridX + gridW + 10, yy + 4, c2);
  }
}

void drawMessage(const String &msg) {
  uint16_t bg = tft.color565(4, 12, 22);
  uint16_t border = tft.color565(0, 180, 200);

  tft.fillRoundRect(12, messageY, screenW – 24, messageH, 6, bg);
  tft.drawRoundRect(12, messageY, screenW – 24, messageH, 6, border);

  tft.setTextDatum(MC_DATUM);
  tft.setTextColor(TFT_WHITE, bg);
  tft.setTextSize(2);
  tft.drawString(msg, screenW / 2, messageY + messageH / 2);
  tft.setTextSize(1);
}

void drawAnimatedSpinningMessage(uint8_t step) {
  String txt = “SPINNING”;
  uint8_t dots = step % 4;

  for (uint8_t i = 0; i < dots; i++) {
    txt += “.”;
  }

  drawMessage(txt);
}

void drawInfoBar() {
  uint16_t bg = tft.color565(3, 9, 16);
  uint16_t border = tft.color565(0, 140, 110);
  uint16_t txt = tft.color565(170, 255, 220);

  tft.fillRoundRect(12, infoY, screenW – 24, infoH, 6, bg);
  tft.drawRoundRect(12, infoY, screenW – 24, infoH, 6, border);

  tft.setTextDatum(ML_DATUM);
  tft.setTextColor(txt, bg);
  tft.setTextSize(2);

  String left = “Credits ” + String(credits);
  String right = “Saved ” + String(totalCoinsSaved);

  tft.drawString(left, 18, infoY + infoH / 2);
  tft.drawString(right, screenW / 2 + 6, infoY + infoH / 2);

  tft.setTextSize(1);
}

void drawMainScreen() {
  drawBackground();
  drawElectroDecorStatic();
  drawHeaderAnimated(false);
  drawReels();
  drawMessage(messageText);
  drawInfoBar();
}

// ————————————————————
// Spin animation only. No idle animation is used.
// ————————————————————
void updateSpinAnimation() {
  if (millis() – lastSpinFxTime < SPIN_ANIM_MS) return;

  lastSpinFxTime = millis();
  spinFxStep++;

  drawHeaderAnimated(true);
  drawElectroDecorAnimated(true);
  drawCenterPaylineAnimated(true);
  drawSpinIndicators(spinFxStep);
  drawAnimatedSpinningMessage(spinFxStep);
}

// ————————————————————
// Game logic
// ————————————————————
void initReels() {
  for (int col = 0; col < REEL_COUNT; col++) {
    for (int row = 0; row < ROW_COUNT; row++) {
      reelSymbols[col][row] = random(0, SYMBOL_COUNT);
      finalSymbols[col][row] = reelSymbols[col][row];
    }
  }

  reelSymbols[0][1] = SYMBOL_CHERRY;
  reelSymbols[1][1] = SYMBOL_SEVEN;
  reelSymbols[2][1] = SYMBOL_BAR;
}

int randomSymbol() {
  int r = random(0, 100);

  if (r < 25) return SYMBOL_CHERRY;
  if (r < 43) return SYMBOL_LEMON;
  if (r < 60) return SYMBOL_BELL;
  if (r < 76) return SYMBOL_BAR;
  if (r < 92) return SYMBOL_DIAMOND;
  return SYMBOL_SEVEN;
}

void addCoin() {
  credits++;
  totalCoinsSaved++;

  messageText = “Coin detected”;
  drawMessage(messageText);
  drawInfoBar();

  Serial.println(“Coin detected”);
}

void startSpin() {
  if (gameState == STATE_SPINNING) return;

  if (credits < SPIN_COST) {
    messageText = “Insert coin first”;
    drawMessage(messageText);
    return;
  }

  credits -= SPIN_COST;
  activeWinLine = WIN_NONE;

  for (int col = 0; col < REEL_COUNT; col++) {
    for (int row = 0; row < ROW_COUNT; row++) {
      finalSymbols[col][row] = randomSymbol();
    }
    reelStopped[col] = false;
  }

  gameState = STATE_SPINNING;
  spinStartTime = millis();
  lastReelUpdateTime = 0;
  lastSpinFxTime = 0;
  spinFxStep = 0;

  drawReels();
  drawInfoBar();
  drawAnimatedSpinningMessage(0);

  Serial.println(“Spin started”);
}

int payoutForThree(int a, int b, int c) {
  if (!(a == b && b == c)) return 0;

  if (a == SYMBOL_SEVEN)   return 20;
  if (a == SYMBOL_DIAMOND) return 8;
  if (a == SYMBOL_BAR)     return 6;
  if (a == SYMBOL_BELL)    return 8;
  if (a == SYMBOL_LEMON)   return 4;
  if (a == SYMBOL_CHERRY)  return 4;

  return 0;
}

String lineName(WinLine line) {
  switch (line) {
    case WIN_TOP:       return “TOP”;
    case WIN_MIDDLE:    return “MIDDLE”;
    case WIN_BOTTOM:    return “BOTTOM”;
    case WIN_DIAG_DOWN: return “DIAGONAL”;
    case WIN_DIAG_UP:   return “DIAGONAL”;
    default:            return “”;
  }
}

bool is777JackpotWin() {
  // Gate opens only for a real 777 line, not for other payouts.
  if (reelSymbols[0][0] == SYMBOL_SEVEN && reelSymbols[1][0] == SYMBOL_SEVEN && reelSymbols[2][0] == SYMBOL_SEVEN) return true;
  if (reelSymbols[0][1] == SYMBOL_SEVEN && reelSymbols[1][1] == SYMBOL_SEVEN && reelSymbols[2][1] == SYMBOL_SEVEN) return true;
  if (reelSymbols[0][2] == SYMBOL_SEVEN && reelSymbols[1][2] == SYMBOL_SEVEN && reelSymbols[2][2] == SYMBOL_SEVEN) return true;
  if (reelSymbols[0][0] == SYMBOL_SEVEN && reelSymbols[1][1] == SYMBOL_SEVEN && reelSymbols[2][2] == SYMBOL_SEVEN) return true;
  if (reelSymbols[0][2] == SYMBOL_SEVEN && reelSymbols[1][1] == SYMBOL_SEVEN && reelSymbols[2][0] == SYMBOL_SEVEN) return true;

  return false;
}

int evaluatePayout(String &resultMessage) {
  int bestPayout = 0;
  WinLine bestLine = WIN_NONE;

  int p = payoutForThree(reelSymbols[0][0], reelSymbols[1][0], reelSymbols[2][0]);
  if (p > bestPayout) { bestPayout = p; bestLine = WIN_TOP; }

  p = payoutForThree(reelSymbols[0][1], reelSymbols[1][1], reelSymbols[2][1]);
  if (p > bestPayout) { bestPayout = p; bestLine = WIN_MIDDLE; }

  p = payoutForThree(reelSymbols[0][2], reelSymbols[1][2], reelSymbols[2][2]);
  if (p > bestPayout) { bestPayout = p; bestLine = WIN_BOTTOM; }

  p = payoutForThree(reelSymbols[0][0], reelSymbols[1][1], reelSymbols[2][2]);
  if (p > bestPayout) { bestPayout = p; bestLine = WIN_DIAG_DOWN; }

  p = payoutForThree(reelSymbols[0][2], reelSymbols[1][1], reelSymbols[2][0]);
  if (p > bestPayout) { bestPayout = p; bestLine = WIN_DIAG_UP; }

  activeWinLine = bestLine;

  if (bestPayout > 0) {
    if (bestPayout >= 20) {
      resultMessage = “JACKPOT ” + lineName(bestLine) + ” +” + String(bestPayout);
    } else {
      resultMessage = “WIN ” + lineName(bestLine) + ” +” + String(bestPayout);
    }
    return bestPayout;
  }

  int cherryCount = 0;
  if (reelSymbols[0][1] == SYMBOL_CHERRY) cherryCount++;
  if (reelSymbols[1][1] == SYMBOL_CHERRY) cherryCount++;
  if (reelSymbols[2][1] == SYMBOL_CHERRY) cherryCount++;

  if (cherryCount == 2) {
    activeWinLine = WIN_MIDDLE;
    resultMessage = “Two cherries +1”;
    return 1;
  }

  resultMessage = “No win”;
  return 0;
}

void finishSpin() {
  String resultMessage;
  int payout = evaluatePayout(resultMessage);

  credits += payout;
  messageText = resultMessage;

  drawReels();
  drawWinLine(activeWinLine);
  drawMessage(messageText);
  drawInfoBar();
  drawHeaderAnimated(false);
  drawElectroDecorStatic();

  if (is777JackpotWin()) {
    openGateServo();
  }

  gameState = STATE_RESULT;

  Serial.print(“Result: “);
  Serial.print(resultMessage);
  Serial.print(” | Payout: “);
  Serial.println(payout);
}

void updateSpin() {
  unsigned long now = millis();
  unsigned long elapsed = now – spinStartTime;

  if (now – lastReelUpdateTime < REEL_SPEED_MS) return;
  lastReelUpdateTime = now;

  bool allStopped = true;

  for (int col = 0; col < REEL_COUNT; col++) {
    if (!reelStopped[col]) {
      if (elapsed >= reelStopTime[col]) {
        for (int row = 0; row < ROW_COUNT; row++) {
          reelSymbols[col][row] = finalSymbols[col][row];
        }
        reelStopped[col] = true;
        drawColumn(col, true);
      } else {
        for (int row = 0; row < ROW_COUNT; row++) {
          reelSymbols[col][row] = randomSymbol();
        }
        drawColumn(col, false);
      }
    }

    if (!reelStopped[col]) {
      allStopped = false;
    }
  }

  drawCenterPaylineAnimated(true);

  if (allStopped) {
    finishSpin();
  }
}


// ————————————————————
// Jackpot gate servo
// ————————————————————
void setupGateServo() {
  gateServo.setPeriodHertz(50);
  gateServo.attach(GATE_SERVO_PIN, GATE_SERVO_MIN_US, GATE_SERVO_MAX_US);

  // Force the gate into the safe closed position at startup.
  gateServo.write(GATE_SERVO_CLOSED_ANGLE);
  gateClosePending = false;

  Serial.println(“Gate servo set to 0 degrees at startup”);
}

void openGateServo() {
  gateServo.write(GATE_SERVO_OPEN_ANGLE);
  gateOpenedTime = millis();
  gateClosePending = true;
  Serial.println(“777 jackpot: gate servo opened”);
}

void closeGateServo() {
  gateServo.write(GATE_SERVO_CLOSED_ANGLE);
  gateClosePending = false;
  Serial.println(“Gate servo closed / 0 degrees”);
}

void updateGateServo() {
  if (!gateClosePending) return;

  if (millis() – gateOpenedTime >= GATE_SERVO_OPEN_TIME_MS) {
    closeGateServo();
  }
}

// ————————————————————
// Coin sensor
// ————————————————————
bool readCoinSensorActive() {
  return digitalRead(COIN_SENSOR_PIN) == COIN_SENSOR_ACTIVE_STATE;
}

void IRAM_ATTR coinSensorISR() {
#if USE_COIN_SENSOR
  unsigned long nowUs = micros();
  unsigned long lockoutUs = COIN_INTERRUPT_LOCKOUT_MS * 1000UL;

  // Capture only the active edge. This ISR must stay very small.
  // The main loop decides whether the coin input is currently armed.
  if (nowUs – lastCoinInterruptUs >= lockoutUs) {
    lastCoinInterruptUs = nowUs;
    coinPulseDetected = true;
  }
#endif
}

void updateCoinSensor() {
#if USE_COIN_SENSOR
  static unsigned long lastPrintTime = 0;

  // Armed/released logic:
  // 1. Count the first active edge.
  // 2. Ignore every further edge while the same coin is still passing.
  // 3. Re-arm only after the sensor is free for a stable time and the
  //    coin-count lockout has expired.
  static bool coinArmed = true;
  static unsigned long inactiveSince = 0;
  static unsigned long lastAcceptedCoinMs = 0;

  unsigned long now = millis();
  bool sensorActive = readCoinSensorActive();

  if (sensorActive) {
    inactiveSince = 0;
  } else {
    if (inactiveSince == 0) {
      inactiveSince = now;
    }

    if ((now – inactiveSince >= COIN_RELEASE_STABLE_MS) &&
        (now – lastAcceptedCoinMs >= COIN_COUNT_LOCKOUT_MS)) {
      coinArmed = true;
    }
  }

  bool edgeDetected = false;

  noInterrupts();
  if (coinPulseDetected) {
    coinPulseDetected = false;
    edgeDetected = true;
  }
  interrupts();

  if (edgeDetected && coinArmed &&
      (now – lastAcceptedCoinMs >= COIN_COUNT_LOCKOUT_MS)) {
    addCoin();
    lastAcceptedCoinMs = now;
    coinArmed = false;
    inactiveSince = 0;
    Serial.println(“Coin accepted: first active edge counted”);
  } else if (edgeDetected) {
    Serial.println(“Coin edge ignored: waiting for release / lockout”);
  }

  if (now – lastPrintTime > COIN_DEBUG_PRINT_MS) {
    lastPrintTime = now;
    Serial.print(“Coin sensor state: “);
    Serial.print(sensorActive ? “HIGH / blocked” : “LOW / free”);
    Serial.print(” | armed: “);
    Serial.println(coinArmed ? “YES” : “NO”);
  }
#endif
}

// ————————————————————
// Start button
// ————————————————————
void updateSpinButton() {
  static bool lastState = HIGH;
  static unsigned long lastPressTime = 0;

  bool state = digitalRead(SPIN_BUTTON_PIN);

  if (lastState == HIGH && state == LOW) {
    if (millis() – lastPressTime > SPIN_BUTTON_DEBOUNCE_MS) {
      startSpin();
      lastPressTime = millis();
      Serial.println(“Start button pressed”);
    }
  }

  lastState = state;
}

Code Explanation

Libraries

The code uses TFT_eSPI for the display, XPT2046_Touchscreen for future touch support, and ESP32Servo for controlling the gate servo.

Coin Input

The coin sensor is connected to GPIO34. The code expects the signal to become HIGH when the coin blocks the light gate. An interrupt captures the active edge, while the main loop handles lockout and re-arming so that one coin is not counted twice.

Spin Button

The button is connected to GPIO33 and uses the ESP32 internal pull-up. The firmware detects the falling edge from HIGH to LOW and starts a spin if enough credits are available.

Game State Machine

The firmware uses three main states: idle, spinning, and result. During a spin, the reels update with a short animation. After the reels stop, the code checks the winning condition and updates the credits or opens the servo gate.

Jackpot Gate

The servo starts in the closed position. When the slot machine hits 777, the code moves the servo to the open angle, waits for the configured open time, and then closes the gate again.

13. Next Improvements

The first prototype proves that the concept works. For the next version, the biggest improvements are mechanical and visual rather than electrical.

Cleaner housingImprove the 3D model, screw points, display mount, and service access.

Better cable managementUse connectors, shorter cables, and possibly a small custom PCB.

Improved gateMake the locking mechanism stronger, smoother, and harder to bypass.

Arcade front panelAdd a cleaner button layout, graphics, labels, and a more polished look.

Final Thoughts

This project is a fun example of combining simple electronics with a mechanical idea. The electronics are not very complicated on their own: one sensor, one button, one display, and one servo. The interesting part is how these pieces work together to create a small interactive machine.

Feel free to recreate this project, change the winning chances, modify the display design, or build a completely different housing. If you build your own version, make sure the money chamber is mechanically safe and that the electronics are powered correctly.