Bouw een Arduino-aangedreven Flipperautomaat: DIY-gids

Onderdelen en benodigdheden

Over dit project

Arduino-bestuurde Flipperautomaat

Het bouwen van een Arduino-bestuurde flipperautomaat vereiste een combinatie van houtbewerking, mechanica, elektronica en programmeren. Het duurde ongeveer zes maanden deelwerk en was het meest ingewikkelde ding dat ik ooit gebouwd heb. Voornamelijk omdat ik weinig informatie kon vinden over het bouwen van een flipperautomaat.

Dit document beschrijft hoe deze machine gebouwd is. Ik probeer voldoende referenties te geven zodat je, als je er zelf een wilt bouwen, een makkelijkere tijd hebt dan ik. Tegelijkertijd kan ik niet genoeg benadrukken hoe belangrijk testen is. Ik gebruikte een reserve stuk multiplex om elk component te prototypen voordat ik het in de echte machine installeerde. Dit bespaart je op de lange termijn veel frustratie.

Zoals je ziet, heeft de machine een houten kast en gebruikt commercieel beschikbare flipper-onderdelen. De machine wordt bestuurd door een enkele Arduino Mega 2560. Wil je de machine in actie zien? Ga naar deze link of bekijk de video.

De Kast

De kast is gemaakt van eiken-gefineerd multiplex uit de bouwmarkt. Alle maten in inches. Voor- en achterpaneel: 20H x 23W. Zijpaneel: 20H x 47L. Stukken zijn met gehronde randen gesneden en verbonden met een lamello-zager en houtlijm. Zakgaten en lijm hadden ook gewerkt. De machine moet veel aankunnen, dus het moet stevig zijn. Voor het samenvoegen zaagde ik ook een ¾" spleet 1 inch vanaf de bodem. Plak de plank niet vast; hij moet zweven voor uitrekking/krimp. De plank houdt de hoofvoeding en de voeding voor de decoratieve LED-strip onder het deksel. Het speelvlak is 22w x 42L. Merk op dat het aanzienlijk korter is dan de kast. Dit geeft ~3 inch voor de draad naar de flipperknoppen en LED-lichten, en ruimte voor de balplunger.

Het speelvlak rust op kleine houten blokken geschroefd aan de zijkanten, ~4 inch onder de bovenkant. Om aan de ingewanden te komen, open je het deksel, haal het speelvlak eruit en keer het om.

Kast en speelvlak zijn allemaal rechte hoeken. De helling van het spel wordt door de poten gegeven. Flipperautomaten hebben hoeken van 1 tot 7 graden. Hoe hoger de hoek, hoe sneller het spel. Omdat ik niet wist welke hoek ik nodig had, maakte ik de poten verstelbaar. De poten zijn houten en verkrijgbaar in de meeste bouwmarkten. Ik boorde een gat van 12 inch diep in het einde van elke poot met een augerboor. Aan de onderkant gebruikte ik twee-componenten epoxy om een 3/8 inch moernippel te monteren. Let op dat geen lijm op de draad of in het gat komt. Daarna steek je een 12 inch 3/8 inch draadstang in de poot en draai je een moer erop. Daarna een nivelleringsvoet erop. De voet en moernippels vind je via de links hieronder.

https://www.mscdirect.com/product/details/40610032

https://www.mscdirect.com/product/details/67300962

Tafelpotmontageplaten werden aan de bodemplank geschroefd en de poten erin. Om de hoogte te verstellen: moer losdraaien, draadstang in/uit draaien, moer weer vastdraaien.

Op de foto zie je een netstekker en USB-kabel. De stekker komt van een stekkerdoos achter de machine; alles gaat erin zodat één schakelaar alles aan/uit zet. De USB-kabel is er om de Arduino te reprogrammeren zonder het speelvlak te hoeven demonturen.

Het Dekseltje

Het dekselraam is van eikenhout en heeft dezelfde buitenafmetingen als de kast. Boven- en zijkanten 1,5 inch breed, onderkant 5 inch breed. De extra breedte onderaan verbergt de speling tussen speelvlak en kast. Een spleet werd aan de binnenkant van de raamstukken gefreesd om het Plexiglas te houden. Ik koos Plexiglas boven glas omdat het lichter, veiliger en makkelijker te zagen is. Het deksel is met zakgaten gemonteerd zodat het ontneembaar is voor eventuele vervanging van het Plexiglas. Ik monteerde ook een strip kleurrijke LED-lichten onder het deksel voor decoratie. Tenslotte het deksel met een piano-scharnier aan de kast bevestigd, ingelast in zowel deksel als kast.

Arduino

De Arduino Mega 2560 doet eigenlijk vier dingen: detecteert wanneer schakelaars activeren, zet lichten aan/uit, houdt score bij, en toont score en balnummer op een klein LCD. Meeste bedrading is simpel. Doelen zijn verbonden met een digitale input en grond. De input wordt geconfigureerd met:

pinMode(Pin_Nummer, INPUT_PULLUP)

Wanneer de code detecteert dat de input van hoog naar laag gaat, weet hij dat het doel geraakt is en zet de bijbehorende LED-pinball-lamp aan.

De enige complicatie zit in de Pop Bumpers. Rolover-schakelaars en doelen krijgen hun stroom van de Arduino. Pop Bumpers krijgen hun stroom van een aparte 25V-voeding omdat ze meer stroom nodig hebben dan de Arduino kan leveren. Pop Bumpers hebben wel een schakelaar die ze activeert, maar ik kan die niet direct uitlezen vanwege de hoge spanning. Dus ik stuur de uitgang van de Pop Bumper-schakelaar eerst naar een spanningsdeler. Een voorbeeld van een spanningsdeler vind je hier. Na de spanningsdeler is de spanning terug naar 5V en kan de Arduino hem aan. Ik ontdekte dat ik minder valse metingen kreeg met de Analog-inputs, omdat spanningsdelers altijd een beetje lekkage hebben. Met Analog-inputs kon ik een drempelwaarde controleren om signaal van ruis te scheiden.

Tijdens het spel, als alle apparaten van een bepaald type (doelen, pop bumpers, of rollovers) geactiveerd waren, programmeerde ik de Arduino om alle lichten voor die apparaten te laten knipperen en de scoring te verhogen.

Ik gebruikte ook een kleine krachtsensor om te detecteren wanneer een bal verloren was. Hiermee houd ik het aantal gespeelde ballen bij en bepaal ik wanneer het spel voorbij is. Bij game over knipperen alle lichten in volgorde.

Tot slot gebruikte ik de Arduino om score en balnummer weer te geven.

Het bijgevoegde schema toont hoe elk van de hoofdcomponenten aangesloten is. Het schema zou te verwarrend zijn als ze allemaal getoond zouden worden.

Voeding

Voor de flippercomponenten koos ik een 24V-voeding. Deze had voldoende vermogen voor de flippers en slingshots. Het is iets zwak voor de pop bumpers. Je kunt een krachtigere voeding gebruiken; dan moet je wel je eigen spanningsdelers maken, aangezien ik er maar tot 25V kon vinden. Info over het maken van een spanningsdeler hier.

In plaats van alles direct op de voeding aan te sluiten, liep ik draden naar twee busbars die ik onder het speelvlak monteerde. Dit maakte het veel makkelijker om de verschillende componenten aan te sluiten. Je ziet een van de busbars in de tweede foto in de Slingshot-sectie. Verkrijgbaar in de bouwmarkt in de elektro-afdeling.

Balplunger / Schutter

De balplunger werd gekocht via:
https://www.marcospecialties.com/pinball-parts/B-12445

Er moet een gat door de voorkant van de kast geboord worden voor de plunger. Deze wordt dan aan de binnenkant geschroefd. Erg nauwkeurig uitlijnen met het speelvlak. Leg een lat op het speelvlak en markeer waar hij de binnenkant raakt. Ga dan omhoog zodat het midden van de plunger gelijk is aan de helft van de balhoogte. (Pinballs zijn 1 1/16 inch en verkrijgbaar bij Pinball.)

Speelvlak

Het speelvlak is van ¼ inch berk-gefineerd multiplex. Voor decoratie kocht ik een foto via NASA:
https://hubblesite.org/gallery/printshop/ps35/

Ik spoot het multiplex in met contactlijm en lamimeerde de poster erop. Daarna omgedraaid en op maat geknipt.

Flippers

De flippers gekocht via:
https://www.pinballlife.com/index.php?p=product&id=172

Bij de meeste flipperonderdelen zit geen nuttige handleiding. De bedrading van de flippers staat in de foto hieronder, afkomstig van de link.

Naast het flippermechanisme heb je een flipperbat, flipper-schakelaar en een knop nodig.

Slingshots

Een complete slingshot-montage vind je hier. Je hebt ook pennen en rubberen banden nodig, op dezelfde locatie. Ook een foto van de slingshot gemonteerd onderaan. Let op: 16 gauge draad werd gebruikt voor alle componenten op de 24V-voeding en 22 gauge draad voor verbindingen naar de Arduino.

De eerste foto toont ook metalen rails naast de flipperbats. Ik kon geen winkel vinden voor de rails, dus maakte ze zelf. Ik gebruikte chroomstaaldraad uit de bouwmarkt (wordt gebruikt om gazons te markeren na insecticiden). Ik knipte en boog de draad, boorde gaten in het speelvlak en epoxyde de rails vast.

Pop Bumpers

Pop bumper-montages kun je hier kopen. Je hebt ook schakelaars en kapjes nodig. Pop bumpers worden geïnstalleerd door drie gaten te boren: twee voor de metalen steunstangen en één voor de as die de schakelaar activeert. Wanneer een bal in de witte schijf (bovenkant) rollt, duwt hij de as naar beneden. Dit activeert de blaasschakelaar, die de solenoid activeert. De solenoid trekt een metalen ring naar beneden die de bal in de tegenovergestelde richting stuurt.

Doelen, rollover-schakelaars en lampen

Doelen verkrijgbaar via:
https://www.marcospecialties.com/pinball-parts/A-14691-5

Rollover-schakelaars en beugels:
https://www.actionpinball.com/parts.php?item=A-12687

De lampen die ik gebruikte worden niet meer gemaakt, maar equivalenten:
https://www.actionpinball.com/parts.php?item=LED4555

Lampenbeugels:
https://www.actionpinball.com/parts.php?item=077-5030-00

Bedrading van al deze is eigenlijk hetzelfde en werd besproken in de Arduino-sectie.

Samenvatting

Als je eenmaal begint, zul je zeker nog andere toevoegingen willen maken, maar dit zou je op weg moeten helpen.

Code

Arduino Flipperautomaat Code

const int TxPin = 17;
long Score = 0;
long OldScore = 0;
long Target = 1;
long Pop = 1;
long Roll = 10;
int Targets[8];
int Rolls[3];
int Pops[4];
int Milli = 10;
int Sum = 0;
int Flash = 100;
int Ball = 0;
int i = 0;
int Shot = 0;
int Lost = 0;
int Pressure = 1024;

#include <SoftwareSerial.h>;
SoftwareSerial mySerial = SoftwareSerial(255, TxPin);

void setup() {
  pinMode(TxPin, OUTPUT);
  digitalWrite(TxPin, HIGH);
  mySerial.begin(9600);
  mySerial.write(12); // Wis scherm
  mySerial.write(17); // Backlight aan
  
  // Doel-inputs
  pinMode(2, INPUT_PULLUP);
  pinMode(3, INPUT_PULLUP);
  pinMode(4, INPUT_PULLUP);
  pinMode(5, INPUT_PULLUP);
  pinMode(6, INPUT_PULLUP);
  pinMode(7, INPUT_PULLUP);
  pinMode(8, INPUT_PULLUP);
  pinMode(9, INPUT_PULLUP);
  
  // Rollover-inputs
  pinMode(10, INPUT_PULLUP);
  pinMode(11, INPUT_PULLUP);
  pinMode(12, INPUT_PULLUP);
  
  // Bal-schakelaars
  pinMode(15, INPUT_PULLUP); // onderste
  pinMode(16, INPUT_PULLUP); // bovenste
  
  // LCD output
  pinMode(17, OUTPUT);
  
  // Doel-lichten
  pinMode(32, OUTPUT);
  pinMode(33, OUTPUT);
  pinMode(34, OUTPUT);
  pinMode(35, OUTPUT);
  pinMode(36, OUTPUT);
  pinMode(37, OUTPUT);
  pinMode(38, OUTPUT);
  pinMode(39, OUTPUT);
  
  // Rolover-lichten
  pinMode(40, OUTPUT);
  pinMode(41, OUTPUT);
  pinMode(42, OUTPUT);
  
  // Pop bumper-lichten
  pinMode(50, OUTPUT);
  pinMode(51, OUTPUT);
  pinMode(52, OUTPUT);
  pinMode(53, OUTPUT);
}

void loop() {
  // Doelen checken
  for (int i = 0; i < 8; i++) {
    if (digitalRead(i + 2) == LOW) {
      Targets[i] = 1;
      Score = Score + Target;
      digitalWrite(i + 32, HIGH);
      delay(Milli);
      break;
    }
  }
  
  Sum = 0;
  for (int i = 0; i < 8; i++) Sum += Targets[i];
  
  if (Sum == 8) {
    for (int j = 0; j < 3; j++) {
      for (int i = 0; i < 8; i++) digitalWrite(i + 32, LOW);
      delay(Flash);
      for (int i = 0; i < 8; i++) digitalWrite(i + 32, HIGH);
      delay(Flash);
    }
    for (int i = 0; i < 8; i++) {
      digitalWrite(i + 32, LOW);
      Targets[i] = 0;
    }
    delay(Flash);
    Target = Target * 5;
  }
  
  // Rolovers checken
  for (int i = 0; i < 3; i++) {
    if (digitalRead(i + 10) == LOW) {
      Rolls[i] = 1;
      Score = Score + Roll;
      digitalWrite(i + 40, HIGH);
      delay(Milli);
      break;
    }
  }
  
  Sum = 0;
  for (int i = 0; i < 3; i++) Sum += Rolls[i];
  
  if (Sum == 3) {
    for (int j = 0; j < 3; j++) {
      for (int i = 0; i < 3; i++) digitalWrite(i + 40, LOW);
      delay(Flash);
      for (int i = 0; i < 3; i++) digitalWrite(i + 40, HIGH);
      delay(Flash);
    }
    for (int i = 0; i < 3; i++) {
      digitalWrite(i + 40, LOW);
      Rolls[i] = 0;
    }
    delay(Flash);
    Score = Score * 2;
    Roll = Roll * 10;
  }
  
  // Pop Bumpers checken (analog)
  for (int i = 0; i < 4; i++) {
    if (analogRead(i) > 500) {
      Pops[i] = 1;
      Score = Score + Pop;
      digitalWrite(i + 50, HIGH);
      delay(Milli);
      break;
    }
  }
  
  Sum = 0;
  for (int i = 0; i < 4; i++) Sum += Pops[i];
  
  if (Sum == 4) {
    for (int j = 0; j < 3; j++) {
      for (int i = 0; i < 4; i++) digitalWrite(i + 50, LOW);
      delay(Flash);
      for (int i = 0; i < 4; i++) digitalWrite(i + 50, HIGH);
      delay(Flash);
    }
    for (int i = 0; i < 4; i++) {
      digitalWrite(i + 50, LOW);
      Pops[i] = 0;
    }
    delay(Flash);
    Pop = Pop * 2;
  }
  
  Skip:
  
  // Balnummer bepalen
  if (digitalRead(15) == LOW) {
    if (Shot == 0) {
      Lost = 0;
      Pressure = analogRead(7) + 20;
      OldScore = -1;
      Ball = Ball + 1;
      if (Ball == 6) {
        Ball = 1; Score = 0; Target = 1; Roll = 1; Pop = 1;
      }
      Shot = 1;
    }
  }
  
  if (digitalRead(16) == LOW) {
    if (Shot == 0) {
      Lost = 0;
      Pressure = analogRead(7) + 15;
      OldScore = -1;
      Ball = Ball + 1;
      if (Ball == 6) {
        Ball = 1; Score = 0; Target = 1; Roll = 1; Pop = 1;
      }
      Shot = 1;
    }
  }
  
  if (analogRead(7) > Pressure) {
    Shot = 0;
    if (Lost == 0) {
      Lost = 1;
      if (Ball == 5) {
        // Game Over - alle lichten knipperen
        for (int j = 0; j < 3; j++) {
          for (int i = 0; i < 3; i++) digitalWrite(i + 40, LOW);
          delay(Flash);
          for (int i = 0; i < 3; i++) digitalWrite(i + 40, HIGH);
          delay(Flash);
        }
        for (int i = 0; i < 3; i++) {
          digitalWrite(i + 40, LOW);
          Rolls[i] = 0;
        }
        for (int j = 0; j < 3; j++) {
          for (int i = 0; i < 4; i++) digitalWrite(i + 50, LOW);
          delay(Flash);
          for (int i = 0; i < 4; i++) digitalWrite(i + 50, HIGH);
          delay(Flash);
        }
        for (int i = 0; i < 4; i++) {
          digitalWrite(i + 50, LOW);
          Pops[i] = 0;
        }
        for (int j = 0; j < 3; j++) {
          for (int i = 0; i < 8; i++) digitalWrite(i + 32, LOW);
          delay(Flash);
          for (int i = 0; i < 8; i++) digitalWrite(i + 32, HIGH);
          delay(Flash);
        }
        for (int i = 0; i < 8; i++) {
          digitalWrite(i + 32, LOW);
          Targets[i] = 0;
        }
        mySerial.write(12); // Wis
        delay(5);
        mySerial.print(Score);
        mySerial.write(13); // Form feed
        mySerial.print("Game Over!!!");
      }
    }
  }
  
  // Naar LCD printen
  if (Score != OldScore) {
    mySerial.write(12); // Wis
    delay(5);
    mySerial.print(Score);
    mySerial.write(13);
    mySerial.print("Bal = ");
    mySerial.print(Ball);
    OldScore = Score;
  }
}

Schema's