Engineering Applications

Pinball Project Brief

This is an example of a pinball machine similar to the one that we could create.

These are the total requirements for our functional prototype that we are expected to complete by a certain date.

We will demonstrate the use of science, technology, engineering, art, and math skills throughout this project.

These are the final pinball machine requirements that we are expected to meet by the end of the project.

GROUP CONTRACT

xander greene and adia lovell Group Contract.doc

This is the group contract for our project that states all of my parter and I's commitments to this project enforced with a signature.

LCD scoreboard with message

SCORE BOARD.pdf

This is the first step of our project, which was to create an LCD board circuit to later present the scores on the pinball machine.

Pinball Research (Field trip to pinball arcade)

Today we went to a pinball arcade and our goal was to learn the insides and outs of pinball machines. We learned what components they have, what most of them have in common, and about individual unique components.

Pinball machine elements

All pinball machines have these elements in common;

bumpers
sliders
flippers
scoreboard
lights
start button
ball guides
ball guides with shooters
launcher
obstacles
power switch
coin slots (we will not have these)
sound effects
theme
graphics
score information sheets
variety of ways to score with different score values

How these major components

Bumpers

The bumpers are a component of a pinball machine that register a hit when the ball collides with them resulting in a very fast movement of the ball throughout the bumpers.

Ball Guides with shooters

These are the ball guides with shooters which are placed near the flippers at the bottom of the board. Their job is to change the trajectory of the ball once it gets to the bottom of the board to throw the user's focus off and create an unexpected change of direction to the ball.

Flippers

Flippers are a component of a pinball machine that is used to direct the ball in a certain direction. They are controlled by two buttons on each side of the machine and they propel the ball up the board.

Launcher

The launcher is a component of the pinball machine that launches the ball into the board by using a pull mechanism or a button mechanism. A spring propels the launcher.

Start button

This is the component of the pinball machine that sets up the scoreboard and inserts the ball into the launcher pad.

Ball

This is the man focus of the pinball machine and the component that scores you points.

Motion Sensors that recognize the ball's near movements cause the light displays to activate and react and create patterns. The points increase when you hit the ball past the obstacles and into a certain place such as a jackpot or a secret hole.

Assigned Pinball Machine

Adia and I were assigned a pinball machine and were tasked with taking pictures of each component and angle of the pinball machine and these are some of the pictures we ended up with. There were many ways you ould score on teh

Gameplay video

IMG_0117.MOV

This is a video of me playing the pinball machine and showing different ways points can be scored. One example of a way you could score points on this particular machine was shooting the ball into a little tunnel. Another way you could score was to land the ball in the secret holes past the bumpers. The last way you could score was to shoot the ball into the pirate ship, but it was very difficult because it was the grand prize.

3-D Printed Selenoid piece for launcher

This is a 3-D printed piece we made for the launcher by exporting a design in onshape and transferring it to a software called Cura that makes a file the 3-D printer can use.

Scoreboard Mount

This is the wooden mount Adia and I created for our scoreboard. We used onshape to put together this mount and edited the sketch until we got the exact correct measurements. We then printed the piece out using the glowforge tool.

Scoreboard with buttons

IMG_0984.MOV

This is the video of our scoreboard functioning with the buttons. There are two buttons that control the value of the amount of balls the player has left and the score. The buttons are connected to a breadboard and programmed to respond and change a value each time they are pressed.

Targets and Bumpers Research

https://www.youtube.com/watch?v=yfZipK-Nqeo

Targets

We are going to start designing the targets for my Pinball Machine. In order do to this we will have to thoroughly go through each step of the design process to ensure my target is the best it can possibly be. We will research targets that are currently being used in pinball machines and take notes on their overall design. We will then create a visual of a target by drawing a draft on paper that includes some aspects of the pinball targets we discovered in my research, including a pivot and a switch. We will then transform that drawing into a cad design in OnShape (and make edits if needed) and download the cad file into an accessible file for the 3-D printer. If the intial prototype is not functional and will not work during tests, we will go back to the drawing board and make edits to the design. We will know when it is working when the ball hits the target and it flips a switch. We will know when it is complete when the target and the rest of the ensemble including the switch is permanently attached to the board and connected to the digital scoreboard circuit.

https://www.youtube.com/watch?v=yfZipK-Nqeo

Bumpers

My partner and I are going to start designing our bumpers for my Pinball Machine. In order do to this we will thoroughly complete the steps of the design process to create a quality bumper. For our research, we will look at the bumpers that are already in use in current pinball machines and write down notable components such as the spring, the rod, the spring, etc. We have also watched the video on how to design a pop bumper by using a cad software. We will take the notable components we discovered in the research portion of the process and design our own unique version of a pop bumper by physically drawing it out. We will then transfer ideas from on paper to a cad software such as OnShape and create a 3-D model. After that, we will print it and make adjustments in size or aesthetics if needed. We will test and iterate the pop-bumper by repetitively running trials to measure if the pinball is bouncing off correctly and make edits to the original cad sketch. We will know when it is finished when we compare our model to pop-bumpers being used in official pinball machines and see if we are replicating the same results.

Scoreboard Installed

This is our scoreboard that we coded and wired and installed by drilling 2 holes and cutting a square that fit the outline of the scoreboard.

Power Source installed

This is a picture of me installing our power source, a stage of the project in which Adia and I struggled with. We designed the wooden holder for the power source a total of 4 times. Each time we would cut the wood out using the band saw and screw it in the wood would split in multiple places. We finally got the design to work once we used three different pieces of wood on all 3 surfaces to ensure security.

Switch Mount

This is a wooden switch mount we created in onshape and downloaded the sketch as a DXF file. We then exported the DXF file to the glowforge software, cut out the design, and screwed it in with the light switch.

Switch Mount installed

This is an image of our light switch mount we designed in Onshape being installed with a screw driver.

Setting up Mock Up

We assembled the mock up by lining up each part and screwing them together one by one. We started with the back surface and moved from there.

Bumper Design Process

Brief

We are being tasked with making a bumper for our pinball machine which is one of the many obstacles on our board. Below are the constraints and expectations that we are required to meet for said bumper.

Bumper Constraints and Expectations:

Able to withstand thousands of hits
Pushes down on ball with enough force that the pinball is thrown out.
Detects being hit by ball which triggers the it to slam down on the ball.
Needs internal wiring.
Firmly attached/mounted to your pinball machine (on the bottom).

Research

For our research, we looked at the bumpers that are already in use in current pinball machines and write down notable components such as the spring, the rod, the spring, etc. We have also watched the video on how to design a pop bumper by using a cad software. We will take the notable components we discovered in the research portion of the process and design our own unique version of a pop bumper by physically drawing it out.

Idea Development

For my idea development phase, I drew a draft sketch to get a first idea of what my bumper would look like (To the left). This is only my first prototype sketch, I plan to make changes after I digitally fabricate it and print it out. My second prototoype sketch looks very similar, but all I did was change the size a bit to see if that had a different impact on the contact with the pinball.

3D prototyping; 1st Iteration

Here is my first prototype that is based on my initial rough draft sketch above. I created it in onshape with the guidance of Ms. White and then exported it as an STL file and 3D printed it. The bumper was functional when I tested it but is not entirely secure on the solenoid. It turned out to be a bit small, so I plan to sketch my 2nd iteration as a larger version to see if that makes a difference on the fit of the solenoid.

Changes after Evaluation and Testing

For the evaluation and testing portion of the design process, I tested the durability of my bumper by repeatedly running the solenoid with the light switch to ensure the bumper stayed secured. I had a few issues when testing the functionality of my prototypes because whenever I reprinted the bumper, the middle hole was either too big or too small. I found a solution for this issue in my second iteration.

3D Prototyping; 2nd Iteration

This is the second digitally fabricated prototype that I created using onshape. I edited the overall size and made it a bit bigger to ensure that it makes good contact on the pinball. I also made the middle hole a bit smaller so it fits better on the solenoid. As a temporary solution as a last resort I decided to wrap the inside with tape to get a more secure fit. As a result, the bumper now fits very well

3D Prototyping; 3rd Iteration

This is the 3rd iteration of my 3D printed prototype. In this version, I have two more pieces I printed out to make an entire assembly. I added the bottom piece that attaches to the solenoid and the pointed piece is the part that the pinball touches to trigger the activation of the solenoid. I attached these parts together using two screws instead of filament because I believed it would be more durable. It is not functional because the selenoid does not fit in the whole due to the screws being too close together.

3D Prototyping: 4th Iteration

This is the 4th digitally fabricated model that I have created. I changed this from my previous prototype by making the holes a bit more spaced out in order to fit the solenoid. However, I also edited the pointed trigger part to make it a bit skinnier in hopes of making it easier to trigger when the pinball touches it, but now it doesn't fit on the assembly with the screws. For my next iteration, I plan to make a curved piece using Onshape that triggers the bumper to move when touched by the pinball. I also need to either find longer screws or make the pointed piece shorter in order to assemble the entire thing.

Prototype Progress Chart

This is a chart I am using to track the progress of the functionality of my iterations.

Prototype 5th Iteration

This is the 5th iteration of my bumper prototype. I adjusted the trigger's size to where it would fit around the screws and I made the spike shorter so it would fit in the assembly and make room for the receiver I'm about to make.

Prototype 6th Iteration

This is the 6th iteration of my prototype. For this model, I changed the size of the trigger point to fully wrap around the nails/screws. I also changed the overall height of the assembly by inserting longer nails instead of short screws. The next step for this prototype is to add the cone with a hole that the trigger point aligns with that acts as a receiver for the trigger point.

Prototype 7th iteration

This is the 7th iteration of my bumper prototype. The main changes I wanted to implement were the making of mount and adjusting the height of my bumper to make it more likely to make solid contact with the pinball. I also made the spoon or receiver 3D printed part but now I have to attach the electrical components to it and find a way to add it to the mount assembly.

Changes based on Evaluation and testing:

I need to change the size of the spoon as well as wire the bumper

Prototype 8th iteration

This is the receiver, which is a very essential part of my bumper assembly. It is the component that triggers the circuit and makes the bumper function. The trigger rests in this receiver and when a pinball touches the trigger ring, the spike moves which moves this spoon as well. The tip of the receiver will soon have electrical tape/covering and will touch another receptor once the trigger moves, which sets off the circuit.

Prototype 9th iteration

This the 9th and most recent prototype iteration. For this prototype I have added a cylindrical shape that fits inside my bumper hole and in between my trigger to prevent the pinball from rolling through. I also have fully wired and mounted the bumper assembly.

Neopixel Light Strip Functioning

Neopixel led strip with switch

This is a video of my neopixel light strip circuit fully functioning. I constructed a circuit consisting of a neopixel LED strip, an arduino, and a target button. The circuit works by pressing a button and this command resets the lighting sequence on the LED strip.

Neopixel holder

This is the neopixel holder that I designed on onshape and printed with the glowforge. I precisely measure the distance between each of the led lights and the general size of the strip. This is made out of cardboard and fits exactly onto the led strip.

Pinball flipper research

Some flipper assemblies are composed of mechanical components, some are composed of electrical components, and some consist of a combination of both.

Electrical components that may be required for flippers include electromagnets, motors, solenoids, and switches. Electronic flipper assemblies have different types of spring mechanisms but all electronic flippers work the same way; There's a coil that is an electromagnet, and when it is energized, it pulls in the plunger and transforms the electrical energy into mechanical energy. As a result, this connects the linkage of the circuit and activates a swing arm that flips the flipper. The coil is made out of copper and that is what generates the magnetic force when you apply electricity.

https://www.youtube.com/watch?v=Orxx7UImOYM

Mechanical components that may be needed for the flipper assembly include rods, elastic straps, a counterweight, and aluminum pressers. First, you need to make the flipper "receivers" as I like to call them. They are the components that the buttons with rods are pressing that initiate the flipper action. To make these, you would need metal pieces that connect together on the back of the board to the top facing up where the actual flippers are. You would place it where the metal pieces are perpendicular to the rod and button (like so in the image below) so that the metal pieces are moved, which simultaneously moves the flipper. The spring that is in the form of a triangle in the image below is so the flipper returns to its normal position after the button rod is pressed.

https://www.youtube.com/watch?v=WLvSeg7gFA8

A device that would combine the electronic and mechanical parts to make an electromagnetic flipper assembly would work by using the electromagnet created by the copper coil to pull an iron or aluminum rod which is connected to a lever in the solenoid. The solenoid is activated once the user presses the button or pushes the rod, causing the flipper to flip up, and when the player releases the button or rod, the flipper returns to its normal position.

Pinball Flipper Idea Development

For my design, I am going to do a fully mechanical. My design is going to be quite similar to the fully aluminum one that I researched above. The sketch below represents how my flippers will look on the first initial iteration. Obviously, I will end up making changes to it to improve functionality but for now, I will keep the design of the sketch below for the prototyping phase.

Video of Fully Functional Pinball Machine

70569168469__ACA582F9-0786-4F38-9EFB-1F80BFE0DED9.MOV

IMG_3819.MOV

Final Code for Pinball Machine

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

#include <Adafruit_NeoPixel.h>

#include <PinballOutputHandler.h>

int Contrast = 80;

long score = 0; // a regular int only counts to around 16,000. A long counts to over 2 billion

int ball_count = 3;

int targetbuttonpin1 = 8;

int targetbuttonpin2 = 9;

int targetbuttonpin3 = 10;

int targetbuttonpin4 = 11;

int targetbuttonpin5 = 99;

int targetbuttonpin6 = 99;

int targetbuttonpin7 = 99;

const int buttonPin0 = A2; // the number of the pushbutton pin

int solenoid = A3;

int buttonState0 = 0;

boolean target1triggered = false;

boolean target2triggered = false;

boolean target3triggered = false;

boolean target4triggered = false;

boolean target5triggered = false;

boolean target6triggered = false;

boolean target7triggered = false;

const int buttonPin1 = 5; // the number of the pushbutton pin

int solenoid1 = A1;

const int buttonPin2 = 13; // the number of the pushbutton pin

int solenoid2 = A0;

int buttonState1 = 0;

int buttonState2 = 0;

OutputHandler outputHandler;

// Initialize all the neopixel strips and save them in an array so you can

// change values like brightness later.

#define NUM_STRIPS 7

Adafruit_NeoPixel pixels[NUM_STRIPS] = {

// Initialize the strips with the number of LEDS, pin number, and init parameters.

// Replace the pin numbers with the pins you are using for your neopixel strips

Adafruit_NeoPixel(10, 6, NEO_GRB + NEO_KHZ800),

Adafruit_NeoPixel(10, 7, NEO_GRB + NEO_KHZ800),

Adafruit_NeoPixel(10, 2, NEO_GRB + NEO_KHZ800),

Adafruit_NeoPixel(10, 3, NEO_GRB + NEO_KHZ800),

Adafruit_NeoPixel(10, 4, NEO_GRB + NEO_KHZ800),

Adafruit_NeoPixel(10, 99, NEO_GRB + NEO_KHZ800),

};

// An array to hold output handlers that correspond to the strips

NeoPixelHandler *handlers[NUM_STRIPS]; // to hold handlers that can control 6 strips

// Define custom colors here

NeoPixelColor cyan(0, 255, 255);

LiquidCrystal_I2C lcd(0x27, 20, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display

void setup() {

// variables will change:

// initialize the LED pin as an output:

pinMode(solenoid1, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(buttonPin1, INPUT_PULLUP);

pinMode(solenoid2, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(buttonPin2, INPUT_PULLUP);

Serial.begin(9600);

// initialize the LED pin as an output:

pinMode(solenoid, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(buttonPin0, INPUT_PULLUP);

Serial.begin(9600);

Serial.println("Send in the Serial Monitor a number to simulate a button");

// Initialize the output handler with the neopixel strip objects. Save the handler objects for later.

Serial.println("turningonallneos");

for (int i = 0; i < NUM_STRIPS; i++)

{

handlers[i] = outputHandler.add(pixels[i]); // Note, this library calls begin() on the Adafruit_NeoPixel library.

pixels[i].setBrightness(25); // Set brightness to 10% to save power.

handlers[i]->on(NeoPixelColor::RED);

}

pinMode(targetbuttonpin1, INPUT_PULLUP);

pinMode(targetbuttonpin2, INPUT_PULLUP);

pinMode(targetbuttonpin3, INPUT_PULLUP);

pinMode(targetbuttonpin4, INPUT_PULLUP);

pinMode(targetbuttonpin5, INPUT_PULLUP);

pinMode(targetbuttonpin6, INPUT_PULLUP);

pinMode(targetbuttonpin7, INPUT_PULLUP);

// pinMode(buttonPin2, INPUT_PULLUP);

//delay(2000);

Serial.print("Starting LCD");

lcd.init();

lcd.begin(16, 2);

lcd.backlight();

lcd.setCursor(4, 1);

lcd.print("Play it!");

}

void refreshLCD() {

lcd.setCursor(0, 0);

lcd.print("score = ");

lcd.print(score);

lcd.setCursor(0, 1);

lcd.print("balls left ");

lcd.print(ball_count);

lcd.setCursor(0, 2);

}

void loop()

{

// read the state of the pushbutton value:

buttonState1 = digitalRead(buttonPin1);

buttonState2 = digitalRead(buttonPin2);

// check if the pushbutton is pressed. If it is, the buttonState is HIGH:

if (buttonState1 == LOW) {

Serial.println("button1hit");

// close selenoid

digitalWrite(solenoid1, HIGH);

} else {

// open selenoid

digitalWrite(solenoid1, LOW);

}

if (buttonState2 == LOW) {

Serial.println("button2hit");

// close selenoid

digitalWrite(solenoid2, HIGH);

} else {

// open selenoid

digitalWrite(solenoid2, LOW);

}

//debug("loop");

// read the state of the pushbutton value:

buttonState0 = digitalRead(buttonPin0);

// check if the pushbutton is pressed. If it is, the buttonState is HIGH:

if (buttonState0 == LOW) {

// close selenoid

digitalWrite(solenoid, HIGH);

} else {

// open selenoid

digitalWrite(solenoid, LOW);

}

// int buttonValue = digitalRead(buttonPin2);

int targetbuttonvalue1 = digitalRead(targetbuttonpin1);

int targetbuttonvalue2 = digitalRead(targetbuttonpin2);

int targetbuttonvalue3 = digitalRead(targetbuttonpin3);

int targetbuttonvalue4 = digitalRead(targetbuttonpin4);

int targetbuttonvalue5 = digitalRead(targetbuttonpin5);

int targetbuttonvalue6 = digitalRead(targetbuttonpin6);

int targetbuttonvalue7 = digitalRead(targetbuttonpin7);

// int buttonValue2 = digitalRead(buttonPin2);

// I don't have buttons on my test board, I'm simulating by sending numbers over the Serial Monitor.

//if (Serial.available()) {

// char incomingByte = Serial.read();

// Serial.print("Got input: ");

// Serial.println(incomingByte);

if (targetbuttonvalue1 == LOW) {

if (target1triggered == false) {

target1triggered = true;

score += 100;

refreshLCD();

Serial.println("Blinking Strip 0 with custom color CYAN");

// Call the handler to start the blink. The actuall blinking is handled when you call handleAll();

// blink (color, delay in milliseconds, number of times to repeat)

handlers[0]->blink(cyan, 100, 10);

}

} else {

target1triggered = false;

}

if (targetbuttonvalue2 == LOW) {

if (target2triggered == false) {

target2triggered = true;

score += 100;

refreshLCD();

Serial.println("Blinking Strip 1 with GREEN");

// Call the handler to start the blink. The actual blinking is handled when you call handleAll();

// blink (color, delay in milliseconds, number of times to repeat)

handlers[1]->blink(NeoPixelColor::GREEN, 200, 10);

}

} else {

target2triggered = false;

}

if (targetbuttonvalue3 == LOW) {

Serial.println("target3 is LOW");

if (target3triggered == false) {

target3triggered = true;

score += 100;

refreshLCD();

Serial.println("Blinking Strip 3 with MAGENTA");

// Call the handler to start the blink. The actuall blinking is handled when you call handleAll();

// blink (color, delay in milliseconds, number of times to repeat)

handlers[2]->blink(NeoPixelColor::MAGENTA, 200, 10);

}

} else {

//Serial.println("target3 is HIGH");

target3triggered = false;

}

if (targetbuttonvalue4 == LOW) {

Serial.println("target4 is LOW");

if (target4triggered == false) {

target4triggered = true;

score += 100;

refreshLCD();

Serial.println("Blinking Strip 4 with PINK");

// Call the handler to start the blink. The actuall blinking is handled when you call handleAll();

// blink (color, delay in milliseconds, number of times to repeat)

handlers[3]->blink(NeoPixelColor::PINK, 200, 20);

}

} else {

Serial.println("target4 is HIGH");

target4triggered = false;

}

// } else if (incomingByte == '1') {

// Serial.println("Blinking Strip 1 RED");

// handlers[1]->blink(NeoPixelColor::RED, 250, 5);

// } else if (incomingByte == '2') {

// Serial.println("Blinking Strip 2 PINK");

// handlers[2]->blink(NeoPixelColor::PINK, 200, 20);

// } else if (incomingByte == '3') {

// Serial.println("Blinking Strip 3 GREEN");

// handlers[3]->blink(NeoPixelColor::GREEN, 100, 30);

// } else if (incomingByte == '4') {

// Serial.println("Setting strip 0 to MAGENTA");

// handlers[0]->on(NeoPixelColor::MAGENTA);

// } else if (incomingByte == '5') {

// Serial.println("Turning off strip 0");

// handlers[0]->off();

// } else if (incomingByte == '6') {

// Serial.println("Chasing strip 0 up in YELLOW");

// // chase_up(color, delay in milliseconds, number of times to repeat)

// handlers[0]->chase_up(NeoPixelColor::YELLOW, 50, 6);

// } else if (incomingByte == '7') {

// Serial.println("Chasing strip 0 down in BLUE");

// // chase_down(color, delay in milliseconds, number of times to repeat)

// handlers[0]->chase_down(NeoPixelColor::BLUE, 100, 5);

// } else if (incomingByte == '8') {

// Serial.println("Rainbow cycle strip 0");

// // rainbow_cycle(delay in milliseconds, number of times to repeat

// handlers[0]->rainbow_cycle(1000, 4);

// } else if (incomingByte == '9') {

// Serial.println("Rainbow strip 0");

// // make the strip light up in rainbow colors

//// handlers[0]->rainbow();

//// } else if (incomingByte == '\n') {

// // ignore newlines

// } else {

// Serial.print("Didn't understand input: ");

// Serial.println(incomingByte);

// Read the value of the input. It can either be 1 or 0

// if (targetbuttonvalue1 == LOW) {

// score = score + 500;

// delay(100);

// }

// if (targetbuttonvalue2 == LOW) {

// score = score + 500;

// delay(100);

// }

// if (targetbuttonvalue3 == LOW) {

// score = score + 500;

// delay(100);

// }

// if (targetbuttonvalue4 == LOW) {

// score = score + 500;

// delay(100);

//if (buttonValue2 == LOW)

// ball_count = ball_count - 1;

//delay(100);

// Call the output Handler every time you go through the main loop.

outputHandler.handleAll();

}

Bumper Component

The images above are of the top and bottom view of the bumper. The bumper is a component that presses down and shoots the ball out once the trigger disk comes in contact with the pinball. The bumpers work using a pointed tip that triggers a spoon that signals the solenoid to close when they are connected. All of the wires the bumper assembly includes are connected to a hub called a relay. Unlike the other components of the pinball board, the bumper is made out of 3D-printed material instead of digitally fabricated wood. Our pinball board assembly includes two bumpers, both of which represent the final 2 exes that the player aims to defeat. The bumpers are towards the top of the pinball board, meaning they are much harder to hit, so they add 500 points to the score value once they are hit.

Target Component

The images below and to the side are of the bottom view and top view of the target, a component of the pinball machine that adds to the score of the scoreboard when hit by the ball. Our targets have a very compact and simple design, but through many trials and tests, they were able to withstand hundreds of hits. Each target has a switch that is triggered when the ball makes contact with the front panel, and each target uses two wires to make it functional. Once the switch is hit, several points are added to the scoreboard and the neopixel LED strip attached to each respective target lights up. Our pinball bard included 4 targets, all of which went along with the theme of the board and represented 4 of Ramona's exes, the characters the player had to defeat in order to earn points.

Flipper Component

This is the flipper component of our pinball machine. The pinball machine includes two flippers, one on the left side and one on the right. The flipper's job is to hit the ball across the board and prevent the ball from entering the bottom space of the board. Our flipper is a mechanical flipper, a manual approach to the flipper design where the player has to push in the button rod instead of pressing a button. Our design includes a rod attached to a square that pushes a block of wood connected to a spring that retracts when the player releases their hand frm the flipper presser.

Launcher Component

The Launcher component's function is to launch the ball into the pinball board play area. The launcher uses a spring to form pressure and tension that is released when the player pulls back and lets go of the launcher handle. Our launcher includes a finger joint box design that was made using onshape and a glowforge laser cutter.

Neopixel Component

The Neopixel component is a component that doesn't serve any physical functionality to the pinball machine and is included solely for aesthetic purposes. Four of the seven neopixels in our board are triggered once any of the targets are hit and 3 of the neopixels are constantly on once the pinball machine is plugged in. We made our neopixels 10 pixels long. They are secured using duct tape and zip ties.

Scoreboard Component

The scoreboard component shows the player how well they are doing in the game in terms of how many points they have earned and it shows them how many balls they have left. The scoreboard is an LCD screen that uses 4 wires that connect to both the arduino and the breadboard. Once a target is hit, the point total on the scoreboard increases by 100 points, and once a bumper is hit, the score increases by 500.

Board Graphic

Our board graphic/theme is based on the film Scott Pilgrim Vs. The World, a sci fi musical adventure where Scott Pilgrim has to defeat 7 evil exes in order to date Ramona Flowers.

1) How has this project compared to other projects that you have undertaken (in life/in school)?

This was by far the most difficult and time consuming project I have done in life and school. It was also the most rewarding, because seeing something as complex as a pinball machine go from an idea to a final product is a very gratifying process. This project also taught me more than any other project I have ever done, because I gained knowledge about wiring diagrams, wood working, CAD softwares, teamwork/cooperation, circuits, and much, much more.

2) How did it feel to complete this project?

It felt amazing and extremely rewarding. The feeling of relief when I finally pressed upload and the code worked with all the components was unlike anything I had ever felt before. Completing this project also meant that we had the opportunity to present it to our family and friends as well as elementary schoolers, so I felt very proud to be showcasing something that my partner and I had made completely from scratch and to see people genuinely having a good time playing our machine.

3) What are you most proud of about your project?

I am most proud of the bumper component of the project because I designed that all by myself and for me to make two of them gave me a feeling of profound gratification. I am also proud of it because of its functionality in the fact that the bumper is structurally sound ad can withstand hundreds of hits and that it is consistently triggered when the pinball comes in contact with it.

Page updated

Report abuse