Engineering Applications

Project Brief

The initial brief for our pinball project.

Prototype Requirements

The above picture shows the requirements for the prototype pinball machine.

Project Requirements

The above picture shows the requirements for the final pinball machine.

Project Expectations

The above picture shows what will be expected of us and what we can expect with this project.

Scoreboard with Message

We wired up an LCD display to an arduino and coded it to convey a message.

Pinball Research (Field Trip to Pinball Arcade)

Today we went to a pinball arcade. Our goal was to learn more about pinball machines, what components, they have, and what most of them have in common.

Pinball Machine Elements

All pinball machines have these elements in common:

Bumpers
Flippers
Ball slides
Scoreboard
Start button (releases the balls)
Rounded ball guides
Ball guides with shooters
Launcher
On-off switch
Coin slots (we will not implement these)
Flashing lights
Sound effects
Theme
Graphics
Score information sheet
Variety of ways to score (often times with different score values)

Holt.Niles.Bumpers.MOV

Bumpers

Bumpers can be found throughout the machine but tend to be located near the top-middle. They mash down on the ball, forcing it to move in another direction.

Ball guides with shooters

These triangular pieces are located near the bottom of the machine and launch the ball back. They also appear to use rubber bands which, when touched by the ball, knock it back.

Holt.Niles.BallGuidesWithshooters.MOV

Holt.Niles.Flipper.MOV

Flipper

The flippers respond to user button input and flip the ball back so that it can score more points.

Start Button

The start button turns the machine on and releases the ball so that it can be launched by the player.

(Play video starting at 5:03)

Holt.Niles.Launcher.MOV

Launcher

The purpose of a pinball launcher is to launch the ball into play. It uses a spring so that when the player pulls it back and releases, it forcefully launches the ball.

Lighting Display

Certain lights in the pinball machine turn on or start flashing when the machine is turned on. Other elements light up as a reaction to contact with the ball. This could be when they are hit or when the ball hits something that affects the game's narrative.

kate.duvalgameplay

IMG_1186.MOV

What Causes the Points to Increase

In pinball, one can gain points by hitting certain obstacles in various areas of the machine. Sometimes harder to reach obstacles in harder to reach areas provide more points than other obstacles, so it would be wise for the player to aim for those. Also, some obstacles may light up to signify that it will give more points than usual.

Scoreboard

Above is the scoreboard which displays digits and text like the player's score, "Lives:", "You Lose!", etc.

Play field

Above is a picture of the play field where the player launches the ball and interacts with the various gameplay elements.

Wiring

Above is a picture of the wiring directly under the play field of the pinball machine.

IMG_0351.MOV

Video of Me Playing

To the left is a video of me playing to better understand the game and attempting to engage all the elements of the game. As you can see, the points increase when I flick the ball and when I hit certain obstacles in different areas of the play field.

Bumper Design Process

I'm beginning the process of designing the bumper for my Pinball machine. In order to do this, I'll have to go through the basic steps of the design process. First, I'll research different ways that people have created bumpers for pinball machines so that I can find inspiration, tips and tricks, and ultimately learn about how to build my own. Next, I'll use the data I accumulated from the research phase to begin developing ideas for my own bumper. I'll list out the parts and any unique elements that I need, and may draw sketches to visualize my ideas. The prototyping phase will consist of me designing the bumper in a program like Onshape and then using the 3D printer to print it in real life. Once printed, I'll test how well it bounces the ball back, and gauge if it needs to be adjusted, and how I'll adjust it based on its functionality. I'll also test how well it responds to the electrical input that triggers it to clamp down on the ball as well. I'll know that I've reached my final prototype when it effectively launches the ball back automatically, and when the electricity consistently passes through, leaving little to no room for error when I implement it in the pinball machine.

Scoreboard Responding to Buttons

We used the arduino program, a breadboard, buttons, and an lcd display to create a functional scoreboard. When one button is pressed, the score goes up by 500, when the other is pressed, the number of balls a player has decreases by 1.

IMG_0476.MOV

IMG_0789.MOV

Scoreboard Mount

Using Onshape, I created a mount for the scoreboard that we will be using in our pinball machine. This mount has all the holes lined up and is made to ensure a secure fit on the scoreboard.

3D Printed Solenoid

Using the 3-D printers, we created two solenoid parts which we then epoxied together to create the solenoid. We would this solenoid with thick wire, so that when it comes into contact with metal (the ball) it will bounce back. This part will be used in the bumpers and obstacles of our pinball machine.

Prototype Pinball Box Assembled

During class, we used various wood pieces to create our prototype pinball box. We used a drill and screws to secure the wood together and to secure the scoreboard and its mount to the box.

Switch Mount

Using Onshape, I created a mount for the on/off switch that we will be installing in our pinball machine. I had to measure the switch, as well as measure and align the screw holes with the screws attached to the switch, ensuring that it tightly fits the mount when screwed in.

IMG_0841.MOV

Scoreboard Mount Installed

Using a larger piece of wood, we once again used the glowforge to make the mount that we would use for our pinball machine. We used a drill, hex screws, and a hex bit to attach the mount to the pinball machine.

Power Switch Installed

To attach the switch mount to the pinball machine, we used a drill with a hex bit, hex screws, and a wrench. We also used a light switch cover, screws, and a flat head screwdriver so that none of the electrical components are exposed.

Power Source Installed

We used the band saw to cut a piece of wood which we would then use to hold our power supply in place. Using a drill and some screws, we were able to secure our power supply in our box. We also glued a small piece of wood to the box to prevent the power supply from shifting sideways.

Wiring Power Source

Bumper Design Process:

Brief (Pop-Bumper):

For this section of the project, my partner and I were tasked with designing different parts of the pinball machine. I was tasked with designing a fully functional pop-bumper.

Research

First Bumper Prototype

Using Onshape and a video tutorial, I created the first prototype for my bumper. When pushed downward, it pushes the ball outward with enough force that the ball will launch out and proceed to hit other obstacles. However, this prototype does not meet many of the constraints, one of the most essential being the ability to detect when the ball hits the bumper so that the solenoid activates.

Idea Development

IMG_1586.MOV

Second Prototype

For the next prototype, I created the base of the bumper mechanism and secured it to the part that pressed down on the ball by drilling nails into them. This extension is necessary so that the solenoids can exist under the pinball machine with space for internal wiring and a detection system.

Third Prototype

For my third iteration, I designed the spike and cone pieces which be apart of the bumper's circuit. The idea is that the spike sits around the nails, and when the circular part of the spike is hit by a rolling ball, it pushes that piece into the cone, which will then close the circuit, causing the bumper to push the ball out. Currently, the spike part is way too small, and the cone is not hollow.

Fourth Prototype

For my fourth iteration, I changed the sizing of the spike and made the cone hollow. However, the cone is definitely too thin and unstable so I need to update that for my next iteration. Also, the spike may be too big, but I'll run a practical test before resizing it. My next steps are to see if the spike fits with my current bumper build, and change the thickness of the cone.

Fifth Prototype

IMG_1854.MOV

For my fifth iteration, I redesigned the cone, making it thicker and more sturdy. I'll have to test this before being sure that this is my final cone prototype, but it is much more durable than the previous iteration. I also attempted to test the spike but ran into a stability issue. The nails that hold the bumper together are not stable enough and consistently fall apart, in the video above, you can see me shifting it back and forth before it falls apart. My next step is to develop a more stable way to hold everything together so that it is completely still and does not fall apart, while also allowing me to manually remove it if I need to test various pieces.

IMG_1963.MOV

Sixth Prototype

To make my sixth iteration more stable, I used a spade drill bit to make the holes on the red piece larger. Doing this, I was able to put more of the nail through the red piece, making it more stable. Although this will work for now, I do not think this will e stable enough to take hundreds of hits from a pinball, so I will continue to find a more stable way to hold everything together. My immediate next step is resizing the spike, as I've confirmed that it's too big-in the video you can see that it extends too far that the cone can't fit under it.

Seventh Prototype

To start my seventh iteration, I began creating my bumper mount. I wanted it to be large enough so that I could roll the ball from any direction to test my bumper. The main thing that I need to figure out is how to efficiently attach the bumper to the mount, because currently, it pops out frequently.

Eigtht Prototype

To the left is my eighth iteration for the bottom piece of my bumper. I gave it more depth in hopes that this will make it sturdier, as the nails shouldn't be able to wiggle as much. I have not yet tested it, but I will and make adjustments as needed.

Constraints Checklist

To the left, you can find a google sheet which we are using to track our progress with our various iterations,

IMG_3574.MOV

Neopixel Responding to Button

In class we received neopixels and a button and successfully used the arduino software to make it so that the neopixel reacts when the button is clicked. We will implement this into our pinball machine targets, making the board light up when a target is hit.

Neopixel Mount

Using Onshape I design a mount for the Neopixel. I used a measuring tool in class to measure the size of the rectangular lights and the distance between them. Even with this precise tool I had to resize it a lot until it fit well. I used the Glowforge laser cutter to bring the design to life.

IMG_4061.MOV

Flipper Research:

Source 1

A pinball flipper works by responding to a button press which activates a solenoid. This solenoid is connected to the arm of the flipper (via a spring) and causes it to rotate in a way that activates the flipper on the playfield. There are two circuits, one which supplies the high power current that moves the flipper, and a second lower power current that holds the flipper in place. The button press pushes pieces of metal into each other to complete the circuit.

Sources 2 & 3

Components:

Wire (18 gauge)
- High power, Hold, and Common wire
Female spade quick connects (4.8mm)
Solenoid
- Plunger, Bushing, Link, Coil Sleeve
End of Stroke switch (digital in newer machines)
Mechanical flipper
- Connecting Rod, Bushing

IMG_4117.MOV

Bumper, Target, and Scoreboard Code Integrated

Using the arduino software, I integrated the code for the bumper, target, and scoreboard, so that they all work together. When the bumper or target is hit, the score increases on the scoreboard.

Code:

#include <LiquidCrystal.h>

int Contrast=60;

int score_increase_target = 8; // target pin

int ball_count_button = 9;

const int score_increase_bumper = A2; // bumper pin (touches gnd to activate)

int solenoid = A3; // (solenoid connects to this pin through mix thing

//connected pin

int score = 0;

int ballcount = 4;

int bumperbuttonState = 0;

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

//standard for LCD screen

void setup()

{

analogWrite(6,Contrast);

lcd.begin(16, 2);

// initialize the LED pin as an output:

pinMode(solenoid, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(score_increase_bumper, INPUT_PULLUP);

pinMode(score_increase_target, INPUT_PULLUP);

pinMode(ball_count_button, INPUT_PULLUP);

//Title screen printed

lcd.setCursor(3, 0);

lcd.print("Game Start");

// lcd.setCursor(5, 1);

// lcd.print("Madness");

//title screen animation

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

delay(1000);

lcd.clear();

}

//looping code

void loop() {

bumperbuttonState = digitalRead(score_increase_bumper);

if (bumperbuttonState == LOW) {

// close selenoid

digitalWrite(solenoid, HIGH);

} else {

// open selenoid

digitalWrite(solenoid, LOW);

}

int score_increase_target_value = digitalRead(score_increase_target);

int ball_count_button_value = digitalRead(ball_count_button);

int score_increase_bumper_value = digitalRead(score_increase_bumper);

//reads the value of the input which is either 1 or 0

//when it is on or off, respectively

if (ballcount < 1 == true){

lcd.clear();

lcd.setCursor(6,0);

lcd.print("GAME");

lcd.setCursor(6,1);

lcd.print("OVER");

delay(500);

lcd.clear();

delay(500);

}else{

lcd.setCursor(4,0);

lcd.print("Balls:");

if (score<1) lcd.print('0');

lcd.print(ballcount);

lcd.setCursor(2, 1);

//padding zeroes on scoreboard

lcd.print("Score:");

if (score<100000) lcd.print('0');

if (score<10000) lcd.print('0');

if (score<1000) lcd.print('0');

if (score<100) lcd.print('0');

if (score<10) lcd.print('0');

if (score<0) lcd.print('0');

lcd.print(score);

delay(75);

//code for button one attached to pin8

if(score_increase_target_value == LOW){

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

score += 500;

lcd.clear();

}

if(score_increase_bumper_value == LOW){

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

score += 500;

lcd.clear();

}

//code for button two attached to pin9

if(ball_count_button_value == LOW){

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

lcd.print("L");

delay(500);

ballcount--;

score = 0;

lcd.clear();

}

Making Rounded Ball Guides With CNC Machine

During class, my partner and I utilized the CNC machine to create rounded ball guides for our pinball machines. We started by picking a 3/4" piece of wood and screwing it in in three places. Next, we measured the length & width of our material, and loaded the Onshape file of our design into Carbide Create. We entered the proper settings into Carbide Create (specifying the dimensions, toolpath, etc.) and then added tabs (small areas that the drill bit won't cut through) so that the material would stay in place. When everything was prepared, we saved this file.

Using a program called Carbide Motion, we connected to the CNC machine and loaded in the file from Carbide Create. We then manually moved the cutter to leftmost front corner of the wood, and set this as zero for our x and y values. We also lowered the cutter until it touched the wood, and set this as zero for the z value. Lastly, we turned the machine on and started the job in Carbide Motion.

Neopixel integrated with Bumper, Target, and Scoreboard Code

Code:

#include <Wire.h>

#include <Adafruit_NeoPixel.h>

#include <LiquidCrystal_I2C.h>

#ifdef __AVR__

#include <avr/power.h> // Required for 16 MHz Adafruit Trinket

#endif

// Which pin on the Arduino is connected to the NeoPixels?

#define PIN A4

#define NUMPIXELS 4

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

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

//int Contrast=60;

int targetValueLED = 0; //ORIGINAL

#define DELAYVAL 100 // Time (in milliseconds) to pause between pixels

int targetPinLED = 8; // ORIGINAL

//int ball_count_button = 13;

const int score_increase_bumper = A1; // bumper pin (touches gnd to activate)

int solenoid = A0; // (solenoid connects to this pin through mix thing

const int score_increase_bumper2 = A3; // bumper pin (touches gnd to activate)

int solenoid2 = A2; // (solenoid connects to this pin through mix thing

//connected pin

int score = 0;

int ballcount = 4;

int bumperbuttonState = 0;

int bumperbuttonState2 = 0;

//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

//standard for LCD screen

void setup()

{

lcd.init(); // initialize the lcd

lcd.init();

lcd.backlight();

//analogWrite(6,Contrast);

//lcd.begin(16, 2);

// initialize the LED pin as an output:

pinMode(solenoid, OUTPUT);

pinMode(solenoid2, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(score_increase_bumper, INPUT_PULLUP);

pinMode(score_increase_bumper2, INPUT_PULLUP);

// pinMode(ball_count_button, INPUT_PULLUP);

pinMode(targetPinLED, INPUT_PULLUP);

Serial.begin(9600);

pixels.begin();

//Title screen printed

lcd.setCursor(3, 0);

lcd.print("Game Start");

// lcd.setCursor(5, 1);

// lcd.print("Madness");

//title screen animation

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayRight();

// delay(500);

// lcd.scrollDisplayLeft();

// delay(500);

delay(1000);

lcd.clear();

}

//looping code

void loop() {

// int ball_count_button_value = digitalRead(ball_count_button);

int score_increase_bumper_value = digitalRead(score_increase_bumper);

int score_increase_bumper_value2 = digitalRead(score_increase_bumper2);

int targetValueLED = digitalRead(targetPinLED);

if (targetValueLED ==LOW ) {

Serial.println("targetValue is LOW" + targetValueLED);

pixels.clear(); // Set all pixel colors to 'off'

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

pixels.setPixelColor(i, pixels.Color(255,0,0));

pixels.show();

delay(DELAYVAL);

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

score += 500;

lcd.clear();

}

else {

Serial.println("High");

pixels.clear(); // Set all pixel colors to 'off'

pixels.show();

}

bumperbuttonState = digitalRead(score_increase_bumper);

if (bumperbuttonState == LOW) {

// close selenoid

digitalWrite(solenoid, HIGH);

} else {

// open selenoid

digitalWrite(solenoid, LOW);

}

bumperbuttonState2 = digitalRead(score_increase_bumper2);

if (bumperbuttonState2 == LOW) {

// close selenoid

digitalWrite(solenoid2, HIGH);

} else {

// open selenoid

digitalWrite(solenoid2, LOW);

}

//reads the value of the input which is either 1 or 0

//when it is on or off, respectively

//

// if (ballcount < 1 == true){

// lcd.clear();

// lcd.setCursor(6,0);

// lcd.print("GAME");

// lcd.setCursor(6,1);

// lcd.print("OVER");

// delay(500);

// lcd.clear();

// delay(500);

// }else{

//

// lcd.setCursor(4,0);

// lcd.print("Balls:");

// if (score<1) lcd.print('0');

// lcd.print(ballcount);

lcd.setCursor(2, 1);

//padding zeroes on scoreboard

lcd.print("Score:");

if (score<100000) lcd.print('0');

if (score<10000) lcd.print('0');

if (score<1000) lcd.print('0');

if (score<100) lcd.print('0');

if (score<10) lcd.print('0');

if (score<0) lcd.print('0');

lcd.print(score);

delay(75);

//code for button one attached to pin8

// if(targetValueLED == LOW){

//

// lcd.clear();

// lcd.setCursor(8,0);

// //placement of text, first number is x axis, second is y axis

// score += 500;

// lcd.clear();

//

// }

if(score_increase_bumper_value == LOW){

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

score += 500;

lcd.clear();

}

if(score_increase_bumper_value2 == LOW){

lcd.clear();

lcd.setCursor(8,0);

//placement of text, first number is x axis, second is y axis

score += 500;

lcd.clear();

}

//code for button two attached to pin9

//// if(ball_count_button_value == LOW){

//

// lcd.clear();

// lcd.setCursor(8,0);

// //placement of text, first number is x axis, second is y axis

// lcd.print("L");

// delay(500);

// ballcount--;

// score = 0;

// lcd.clear();

// }

}

Final Pinball Machine

Our pinball graphic is based on the anime "Initial D". Both my partner, Steven Lewis, and I like anime, and he likes cars, so we chose to base it around an anime about cars. This is the reason for our red and black theme.

Video of Each Component Functioning:

IMG_5832.mov

Final Code:

// NeoPixel Ring simple

// Released under the GPLv3 license to match the rest of the

// Adafruit NeoPixel library

#include <Adafruit_NeoPixel.h>

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

#ifdef __AVR__

#include <avr/power.h> // Required for 16 MHz Adafruit Trinket

#endif

// Which pin on the Arduino is connected to the NeoPixels?

#define PIN 12

//this to 1

// How many NeoPixels are attached to the Arduino?

#define NUMPIXELS 4 // Popular NeoPixel ring size

// When setting up the NeoPixel library, we tell it how many pixels,

// and which pin to use to send signals. Note that for older NeoPixel

// strips you might need to change the third parameter -- see the

// strandtest example for more information on possible values.

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

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

int targetValueLED = 0; //ORIGINAL

#define DELAYVAL 100 // Time (in milliseconds) to pause between pixels

int targetPinLED = 13; // ORIGINAL

int ball_count_button = 8;

const int score_increase_bumper = A1; // bumper pin (touches gnd to activate)

int solenoid = A0; // (solenoid connects to this pin through mix thing

const int score_increase_bumper2 = A3; // bumper pin (touches gnd to activate)

int solenoid2 = A2; // (solenoid connects to this pin through mix thing

const int score_increase_bumper3 = 5; // bumper pin (touches gnd to activate)

int solenoid3 = 4; // (solenoid connects to this pin through mix thing

const int score_increase_bumper4 = 3; // bumper pin (touches gnd to activate)

int solenoid4 = 2; // (solenoid connects to this pin through mix thing

//connected pin

long score = 0; // long counts to 2 billion

long lastScore = -1;

int ballcount = 1;

int bumperbuttonState = 0;

int bumperbuttonState2 = 0;

int bumperbuttonState3 = 0;

int bumperbuttonState4 = 0;

void setup() {

lcd.init(); // initialize the lcd

lcd.init();

lcd.backlight();

// initialize the LED pin as an output:

pinMode(solenoid, OUTPUT);

pinMode(solenoid2, OUTPUT);

pinMode(solenoid3, OUTPUT);

pinMode(solenoid4, OUTPUT);

// initialize the pushbutton pin as an input:

pinMode(score_increase_bumper, INPUT_PULLUP);

pinMode(score_increase_bumper2, INPUT_PULLUP);

pinMode(score_increase_bumper3, INPUT_PULLUP);

pinMode(score_increase_bumper4, INPUT_PULLUP);

pinMode(targetPinLED, INPUT_PULLUP);

pinMode(ball_count_button, INPUT_PULLUP);

Serial.begin(9600);

pixels.begin(); // INITIALIZE NeoPixel strip object (REQUIRED)

lcd.setCursor(0, 4);

lcd.print("Game Start");

delay(1000);

lcd.clear();

}

void refreshLCD() {

if (lastScore != score) {

lastScore = score; // only refresh lcd when score changes

lcd.setCursor(4, 0);

lcd.print("Balls:");

if (score < 1) lcd.print('0');

lcd.setCursor(10, 0);

lcd.print(ballcount);

lcd.setCursor(1, 1);

//padding zeroes on scoreboard

lcd.print("Score:");

if (score < 100000) lcd.print('0');

if (score < 10000) lcd.print('0');

if (score < 1000) lcd.print('0');

if (score < 100) lcd.print('0');

if (score < 10) lcd.print('0');

if (score < 0) lcd.print('0');

lcd.print(score);

}

void loop() {

// for (int i = 0; i < NUMPIXELS; i++)

// pixels2.setPixelColor(i, pixels2.Color(255,0,0));

// pixels2.show();

int score_increase_bumper_value = digitalRead(score_increase_bumper);

int score_increase_bumper_value2 = digitalRead(score_increase_bumper2);

int score_increase_bumper_value3 = digitalRead(score_increase_bumper3);

int score_increase_bumper_value4 = digitalRead(score_increase_bumper4);

int ball_count_button_value = digitalRead(ball_count_button);

int targetValueLED = digitalRead(targetPinLED);

bumperbuttonState = digitalRead(score_increase_bumper);

if (bumperbuttonState == LOW) {

// close selenoid

digitalWrite(solenoid, HIGH);

} else {

// open selenoid

digitalWrite(solenoid, LOW);

}

bumperbuttonState2 = digitalRead(score_increase_bumper2);

if (bumperbuttonState2 == LOW) {

// close selenoid

digitalWrite(solenoid2, HIGH);

} else {

// open selenoid

digitalWrite(solenoid2, LOW);

}

bumperbuttonState3 = digitalRead(score_increase_bumper3);

if (bumperbuttonState3 == LOW) {

// close selenoid

digitalWrite(solenoid3, HIGH);

} else {

// open selenoid

digitalWrite(solenoid3, LOW);

}

bumperbuttonState4 = digitalRead(score_increase_bumper4);

if (bumperbuttonState4 == LOW) {

// close selenoid

digitalWrite(solenoid4, HIGH);

} else {

// open selenoid

digitalWrite(solenoid4, LOW);

}

if (targetValueLED == LOW ) {

Serial.println("targetValue is LOW" + targetValueLED);

pixels.clear(); // Set all pixel colors to 'off'

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

pixels.setPixelColor(i, pixels.Color(255, 0, 0));

pixels.show();

delay(DELAYVAL);

//lcd.clear();

//lcd.setCursor(8, 0);

//placement of text, first number is x axis, second is y axis

score += 500;

//lcd.clear();

}

else {

Serial.println("High");

pixels.clear(); // Set all pixel colors to 'off'

pixels.show();

}

if (score_increase_bumper_value == LOW) {

//lcd.clear();

//lcd.setCursor(8, 0);

//placement of text, first number is x axis, second is y axis

score += 500;

//lcd.clear();

}

if (score_increase_bumper_value2 == LOW) {

//lcd.clear();

//lcd.setCursor(8, 0);

//placement of text, first number is x axis, second is y axis

score += 500;

//lcd.clear();

}

if (ballcount < 1 == true) {

lcd.clear();

lcd.setCursor(6, 0);

lcd.print("GAME");

lcd.setCursor(6, 1);

lcd.print("OVER");

delay(500);

lcd.clear();

delay(500);

} else {

refreshLCD();

delay(75);

}

}//

Bumpers

Top View

Under the Board

The bumper uses a solenoid and a switch to push the ball out upon contact. The metal ball rolls over the copper tape, connecting the top piece to the bottom. This closes the circuit causing electricity to flow, sending the signal for the solenoid to activate. Closing this circuit also increases the score by 500 points. When the solenoid activates, it pushes the top of the bumper down, forcing the ball out.

Targets

Top View

Under the Board

When hit by the ball with enough force, the targets close a circuit which increases the score by 500 points and makes the neopixels light up red.

Flippers

Top View

Under the Board

These electronic flippers use solenoids and buttons to activate. When the button is pressed it closes a circuit which activates the solenoid. The solenoid pushes a piece of wood under the board which is attached to the flipper, causing the flipper to move.

Neopixels

Top View

Under the Board

The neopixels are connected to the targets and light up when the targets are clicked. We coded the neopixels to light up red because it fits the red and black theme we have.

Scoreboard

IMG_5472.MOV

Front View

Behind the Board

The scoreboard, like the other components, is wired to an arduino. In the arduino software, we coded a ball counter and score counter that react to other elements on the board (i.e. the bumpers and targets).

Launcher

IMG_5438.MOV

The launcher is a completely mechanical component. When a player pulls it back, it uses the springs to create pressure which allows the player to launch the ball far. The springs also serve to keep the launcher attached to the machine.

Final Reflection:

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

This project is definitely the most challenging project that I've ever undertaken. It required months of diligent work, critical thinking, and the combination of various engineering skills like coding, electrical engineering, and mechanical engineering. We were working all the way up to the deadline and it was a unique experience to say the least.

2) How did it feel to complete this project.

I was very satisfied and relieved when we completed the project. I was proud to see our year-long work finally come to fruition, and I was happy when members of the east lake community were able to play our machine for themselves.

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

I'm very proud of the functionality of our machine. My partner and I used many unique methods to design certain components and it ended up working out in the end. We finished first out of our whole class, and many students and community members liked our finished machine the most. I'm most proud of the fact that my partner and my's determination and work ethic led to a successful product.