Coin pusher on an Arduino Uno

// Coin pusher: the arcade game where a shelf slides back and forth and every
// coin you drop might shove a pile over the edge.
//
//   DROP button     pin 2 -> arcade button -> GND   (INPUT_PULLUP, pressed = LOW)
//   coin-out eye    FC-51 OUT -> pin 3              (LOW while a coin falls past)
//   payout display  TM1637 CLK -> pin 5, DIO -> pin 4
//   light strip     8 WS2812B LEDs, DIN <- pin 6
//   stall switch    microswitch COM -> pin 7, NO -> GND (pressed = LOW)
//   piezo           pin 8 -> piezo -> GND
//   pusher servo    PWM -> pin 9
//
// How to play. You start with 10 coins. Press DROP to drop one onto the
// playfield. The servo sweeps the pusher shelf forward and back, and coins
// pushed off the front fall past the IR eye: each one is paid back to you and
// counted on the display. Three coins in two seconds is a JACKPOT: five bonus
// coins and a light show on the strip.
//
// Stall detection. The pusher's face is on a spring with a microswitch
// behind it. If a coin wedges the shelf while it pushes forward, the face
// gives and the switch closes. The sketch reverses the pusher back out of
// the jam, waits a moment and carries on. Three stalls in ten seconds means
// something is really stuck, so the machine locks itself (a safety
// interlock: no more pushing, no more coins in) until an attendant clears it
// and holds DROP for two seconds.
//
// Skills: a state machine (PUSHING, REVERSING, PAUSED, LOCKED), sweeping a
// servo with millis() instead of delay(), edge detection with debouncing,
// and counting events inside a time window.
//
// The strip's data line usually goes through a 330 ohm resistor on a real
// build; in the simulator a straight wire is fine.

#include <Servo.h>
#include <TM1637Display.h>
#include <Adafruit_NeoPixel.h>

const int DROP_PIN = 2;
const int COIN_PIN = 3;
const int DIO_PIN = 4;
const int CLK_PIN = 5;
const int STRIP_PIN = 6;
const int STALL_PIN = 7;
const int PIEZO_PIN = 8;
const int SERVO_PIN = 9;
const int LEDS = 8;

const int BACK = 40;                         // pusher fully back (degrees)
const int FRONT = 140;                       // pusher fully forward
const int STEP_DEG = 2;                      // degrees per servo step
const unsigned long STEP_MS = 20;            // one step every 20 ms: 1 s a stroke
const unsigned long DROP_GAP_MS = 400;       // one coin at a time
const unsigned long DEBOUNCE_MS = 30;
const unsigned long STALL_CONFIRM_MS = 60;   // the switch must stay closed this long
const unsigned long STALL_WINDOW_MS = 10000;
const int STALLS_TO_LOCK = 3;
const unsigned long PAUSE_MS = 500;
const unsigned long JACKPOT_WINDOW_MS = 2000;
const unsigned long SHOW_MS = 4000;
const unsigned long UNLOCK_HOLD_MS = 2000;

Servo pusher;
TM1637Display display(CLK_PIN, DIO_PIN);
Adafruit_NeoPixel strip(LEDS, STRIP_PIN, NEO_GRB + NEO_KHZ800);

enum State { PUSHING, REVERSING, PAUSED, LOCKED };
State state = PUSHING;

int angle = BACK;
int direction = 1;            // +1 forward, -1 back
unsigned long lastStep = 0;
unsigned long pausedAt = 0;

int credits = 10;
int paidOut = 0;
unsigned long lastDrop = 0;

// The last three coins out, for the jackpot window.
unsigned long recentCoins[3] = {0, 0, 0};
unsigned long showUntil = 0;
int noteIndex = -1;
unsigned long noteAt = 0;
const int FANFARE[] = {784, 988, 1175, 1568};

// Stalls: when each recent one happened.
unsigned long stallTimes[STALLS_TO_LOCK] = {0, 0, 0};
unsigned long stallClosedAt = 0;

// Inputs, debounced.
int coinStable = HIGH, coinRaw = HIGH;
unsigned long coinChanged = 0;
int dropStable = HIGH, dropRaw = HIGH;
unsigned long dropChanged = 0;
unsigned long dropDownAt = 0;

unsigned long lastStripAt = 0;

// Debounce one input. Returns true once, when it settles LOW.
bool settledLow(int pin, int &stable, int &raw, unsigned long &changed, unsigned long now) {
  int r = digitalRead(pin);
  if (r != raw) {
    raw = r;
    changed = now;
  }
  if (r != stable && now - changed >= DEBOUNCE_MS) {
    stable = r;
    return r == LOW;
  }
  return false;
}

void dropCoin(unsigned long now) {
  if (state == LOCKED) {
    Serial.println("Machine locked, no coins in");
    tone(PIEZO_PIN, 196, 200);
    return;
  }
  if (now - lastDrop < DROP_GAP_MS) return;  // too fast: the chute holds one coin
  if (credits == 0) {
    Serial.println("Out of coins");
    tone(PIEZO_PIN, 196, 200);
    return;
  }
  lastDrop = now;
  credits--;
  Serial.print("Coin dropped, ");
  Serial.print(credits);
  Serial.println(" left");
  tone(PIEZO_PIN, 1047, 40);
}

void coinOut(unsigned long now) {
  paidOut++;
  credits++;
  display.showNumberDec(paidOut);
  Serial.print("Coin out! Paid ");
  Serial.println(paidOut);
  tone(PIEZO_PIN, 1568, 30);

  // Slide the window along and see if three fell within two seconds.
  recentCoins[0] = recentCoins[1];
  recentCoins[1] = recentCoins[2];
  recentCoins[2] = now;
  if (recentCoins[0] != 0 && now - recentCoins[0] <= JACKPOT_WINDOW_MS && showUntil == 0) {
    credits += 5;
    showUntil = now + SHOW_MS;
    noteIndex = 0;
    noteAt = now;
    recentCoins[0] = recentCoins[1] = recentCoins[2] = 0;
    Serial.print("JACKPOT! +5 coins, ");
    Serial.print(credits);
    Serial.println(" coins");
  }
}

void stall(unsigned long now) {
  // Keep the last few stall times and count those inside the window.
  for (int i = 0; i < STALLS_TO_LOCK - 1; i++) stallTimes[i] = stallTimes[i + 1];
  stallTimes[STALLS_TO_LOCK - 1] = now;
  if (stallTimes[0] != 0 && now - stallTimes[0] <= STALL_WINDOW_MS) {
    state = LOCKED;
    angle = BACK;
    pusher.write(angle);
    Serial.println("Pusher jammed: locked. Clear it, then hold DROP 2 s");
    tone(PIEZO_PIN, 147, 800);
    return;
  }
  state = REVERSING;
  direction = -1;
  Serial.println("Stall! Reversing pusher");
  tone(PIEZO_PIN, 330, 120);
}

void movePusher(unsigned long now) {
  if (now - lastStep < STEP_MS) return;
  lastStep = now;
  angle += direction * STEP_DEG;
  if (angle >= FRONT) {
    angle = FRONT;
    direction = -1;
  }
  if (angle <= BACK) {
    angle = BACK;
    direction = 1;
    if (state == REVERSING) {
      state = PAUSED;  // back out of the jam: rest a moment before pushing again
      pausedAt = now;
    }
  }
  pusher.write(angle);
}

void drawStrip(unsigned long now) {
  if (now - lastStripAt < 40) return;  // 25 frames a second is plenty
  lastStripAt = now;
  if (showUntil != 0) {
    strip.rainbow((uint16_t)(now * 60));  // the jackpot: every LED, spinning colors
  } else if (state == LOCKED) {
    bool on = (now / 300) % 2 == 0;       // blinking red: call an attendant
    for (int i = 0; i < LEDS; i++) strip.setPixelColor(i, on ? strip.Color(150, 0, 0) : 0);
  } else {
    // One amber light follows the pusher shelf.
    strip.clear();
    int at = (long)(angle - BACK) * (LEDS - 1) / (FRONT - BACK);
    strip.setPixelColor(at, strip.Color(120, 70, 0));
  }
  strip.show();
}

void setup() {
  Serial.begin(9600);
  pinMode(DROP_PIN, INPUT_PULLUP);
  pinMode(COIN_PIN, INPUT_PULLUP);
  pinMode(STALL_PIN, INPUT_PULLUP);
  pusher.attach(SERVO_PIN);
  pusher.write(angle);
  display.setBrightness(0x0f);
  display.showNumberDec(0);
  strip.begin();
  strip.setBrightness(120);
  Serial.println("Coin pusher ready: 10 coins, press DROP");
}

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

  bool dropPressed = settledLow(DROP_PIN, dropStable, dropRaw, dropChanged, now);
  if (dropPressed) {
    dropDownAt = now;
    dropCoin(now);
  }
  if (settledLow(COIN_PIN, coinStable, coinRaw, coinChanged, now)) coinOut(now);

  switch (state) {
    case PUSHING:
      movePusher(now);
      // Stall check: only while pushing forward, and only once the switch
      // has stayed closed long enough to be sure.
      if (direction == 1 && digitalRead(STALL_PIN) == LOW) {
        if (stallClosedAt == 0) stallClosedAt = now;
        if (now - stallClosedAt >= STALL_CONFIRM_MS) {
          stallClosedAt = 0;
          stall(now);
        }
      } else {
        stallClosedAt = 0;
      }
      break;

    case REVERSING:
      movePusher(now);
      break;

    case PAUSED:
      if (now - pausedAt >= PAUSE_MS) {
        state = PUSHING;
        Serial.println("Pushing again");
      }
      break;

    case LOCKED:
      // Unlock: DROP held for two seconds with the jam cleared.
      if (dropStable == LOW && dropDownAt != 0 && now - dropDownAt >= UNLOCK_HOLD_MS) {
        dropDownAt = 0;
        if (digitalRead(STALL_PIN) == LOW) {
          Serial.println("Still jammed");
        } else {
          for (int i = 0; i < STALLS_TO_LOCK; i++) stallTimes[i] = 0;
          state = PUSHING;
          direction = 1;
          Serial.println("Pusher restarted");
          tone(PIEZO_PIN, 880, 100);
        }
      }
      break;
  }

  // The jackpot fanfare, one note at a time without blocking.
  if (noteIndex >= 0 && now - noteAt >= 150) {
    tone(PIEZO_PIN, FANFARE[noteIndex], 120);
    noteAt = now;
    noteIndex = noteIndex < 3 ? noteIndex + 1 : -1;
  }
  if (showUntil != 0 && (long)(now - showUntil) >= 0) {
    showUntil = 0;
    Serial.println("Show over");
  }

  drawStrip(now);
}