Engineering Applications

Pinball Project:

Brief:

This year in Engineering Applications, our year long project is to build our very own pinball machine! Usually we work in partners, but I am in a group with 2 other people, which causes our pinball machine to be a little different from the other groups. Below you will be able to learn about the different components within our machine & the process we went through to complete them.

Overall Constraints

Component Constraints Template Document

Michael Engineering Notebook

Engineering design Notebook

In this notebook we track all the progress and processes taken during each of our projects with a picture and description of what happened on each day of worktime.

Research:

Overall goal and theme's (scoring system/rule baord

IMG_8949.MP4

Launcher/Flippers

The launcher was ok, as in it did the job but sometimes it wouldn't go as far up as you think it would. The flippers were very good and there was no delay, they made the ball go up very far and made it easy to get points.

IMG_8948.MP4

Score board/Sounds

The scoreboard had characters, interesting sound affects when you made bonus or hit something, it even had interesting animations that I thought were cool

IMG_6452.mp4

Rotating component/ lighting/ballguide

In the pinball the soccer spins and when the ball goes in it gets spun then redirected. The lighting was in sync with when the game started and ended and when you hit one of the components to score.

IMG_8949.MP4

Bumpers (towards end)

The bumpers sit right aboce the the flippers and I would say were pretty good although they didn't get used as much when we were playing it.

IMG_8947.MP4

Targets

The target is past the goalie and if you get it past him then you get a points and then he moves to the other side of the goal to change it up.

Launcher:

IMG_9717.mp4

This is a video of us testing our launcher after installing it and reprinting our rocket a a few times for it to print. We have a metal rod which made the launcher much more stable, and easy to put together. One other thing we found is that its reliability is pretty good but it really depends on the user.

Component Constraints Template Document

Contraints of component

The sheet is outlining how we were to be graded on the component and what steps we needed to take to get a good grade. Ms. White tested the efficiency by launhcing it 10 times as well as the durability by launching it hard. It turned out pretty well in the end after a lot of trial and error and we ended up having a very stable and functional launcher

Parts of Launcher:

Scoreboard:

IMG_7905.mp4

Video of component

This is a video of us testing our scoreboard once we installed it into the back of our board. it was programmed to two switch that I press in the video. One increases the score, while the other switch makes the ball count decrease. We added a smoke like design, and later added a rocket

Component Constraints Template Document

Constraints of Scoreboard

My group completed the code section for our scoreboard pretty fast, although I ddi originally struggle to make the game reset after the game over section showed up. I eventually figured it out and later added the ball count to come up after Game over without clicking the switch.

Component parts

Onshape/ Planning of design

Component Constraints Template Document

Constraints of Onshape

This outlines the requirements for the layout we submit, ours layout met every requirement with a few add on's due to the fact that we're a group of three. We placed everything according to our plan as closerly as possible.

All Students Final Pinball Menu Grading / Overall Component Planning

Final grading sheet:

This is the overall grading sheet for our entire pinball with a few extra added components because we are a group of three.

Hand Drawn layout

Onshape Layout

Pinball Machine Lighting Plan and Scoring System

Lighting and Scoring plan

Ball Return:

Constraints:

How it works:

The ball-return mechanism functions like to a beam-break sensor. When an object interrupts the light between the LED emitter and the receiver, the system registers the break and triggers a programmed response through conditional (if) statements. We used this interaction to accurately track and update the ball count.

Code:

Sets up the sensor and LED by configuring the sensor pin as an input with a pull-up resistor and initializing the LED pin for digital output.
Tracks the ball count by detecting when a ball passes the sensor. If the ball-count button is pressed and the sensor beam is broken, the program decreases the Ball_Count variable.
Uses a debounce check so the sensor does not register multiple false signals when a ball hits it.
Prints updates to the console so you can see when the ball count changes during testing.
Defines a Game_Over() function that resets the score, resets the ball count to 3, clears the LCD, and displays “GAME OVER” on the screen for three seconds.
Ensures the game resets properly so the player starts fresh after losing all balls.

Video/photos of functionality:

IMG_9726.mp4

Flipper:

Constraints:

How it works:

The flipper is a critical component of the game’s functionality. It operates through a system of press-fit pieces attached to a central rod. Beneath the playfield, a solenoid provides the upward force needed to activate the flipper. The lower press-fit piece connects directly to the solenoid’s plunger, and a spring—anchored to an elevated section of the solenoid’s mount—returns the mechanism to its resting position. This design ensures consistent, reliable flipper motion and precise control during gameplay.

Code:

Video/photos of functionality:

IMG_6867.mov

Target:

Constraints:

How it works:

The targets serve as the primary scoring mechanism for players. Each target is positioned over an opening in the playfield and aligned with a switch mounted on the underside of the board. When a target is struck with sufficient force, it depresses the switch, triggering a programmed increase in the player’s score. Each target is assigned a unique point value based on its location and difficulty, allowing for a varied and engaging scoring system.

Code

Video/photos of functionality:

copy_EF898059-0B6A-4F19-92BA-D9F7B2556840.mp4

Status: Currently our group is mostly up to date on every function of our pinball, with only a few more targets to add. We also plan to code Neo-pixels to the targets to create a reaction. The flippers look and work pretty well. Both targets function but we plan on trying to make them more sensitive so that it doesn't take as much effort for them to be pushed. We are confident that we can stay on track now that we have caught up on most of our components and look foward to the next step.

Reflection:

One challenge I faced during the build was getting the flipper to strike high enough on the playfield. Although the initial installation seemed successful, testing revealed that the flipper couldn’t reach the top of the board as intended. To address this issue, I rebuilt the entire flipper assembly and experimented with different solutions—adjusting the spring tension, modifying the press-fit components, and changing the angle at which the solenoid was mounted. Through this iterative process, I was ultimately able to achieve the desired range of motion and overcome the challenge.
The component that I am most proud of would probably be the flipper, mainly because it took so long to get it right, I feel that it finally working is something I have to be proud of. Although I do like how well installed my Target and how reliable it works coding wise.

copy_055C63D0-51E3-477B-9FA8-652FAC3035FA.mp4

Bumper:

Michael Engineering Notebook

Bumper Mount

This piece was mounted under the board with the solenoid screwed onto the top piece. It worked effectively and was small enough to the point where it didn't take up to much space on the board

Solenoid Part

Next, this piece was directly press fitted onto the top part of the solenoid in order, this were the rods were screwed into to go through the board board and pull the Saucer down.

Flying Saucer (top piece)

Lastly, this was the final part of the bumper which was decided would be Saucers, we added the two holes that each screw would go into, as well as painted it a silver color to go with our theme.

Photos/Video:

IMG_7102.mov

Servo Component:

Spinning Planet

For one of our servo components we decided one would a continuously spinning planet, we decided we would paint it the color of mars to fit the theme.

Servo Mount

The servo mount was pretty easy because, I used a previous design and modified it to be elevated from the board so that the servo horn would be centered on the prevut hole in our board.

Photos/Video:

IMG_7422.MOV

NeoPixels:

The NeoPixels on the board provide dynamic lighting effects that make the pinball machine more interactive and visually engaging. They are programmed to change colors and patterns based on what is happening in the game, such as when a bumper is hit or when certain actions occur. This gives immediate visual feedback to the player and helps highlight important parts of the board. The NeoPixels also add to the overall design by making the game look more exciting and polished, almost like a real arcade machine. Overall, they enhance both the functionality and appearance of the pinball system.

IMG_1700.MOV

Main Code

"""Simple test for 16x2 character lcd with an I2C LCD backpack."""

import time

import board

import busio

from digitalio import DigitalInOut, Direction, Pull

# LCD Source code is at https://github.com/dhalbert/CircuitPython_LCD

from lcd.lcd import LCD

from lcd.i2c_pcf8574_interface import I2CPCF8574Interface

"""CircuitPython Essentials NeoPixel example"""

import time

import board

from rainbowio import colorwheel

import neopixel

import digitalio

import time

import board

# For more information on how to use digitalio on Circuit Python, see

# https://learn.adafruit.com/circuitpython-essentials/circuitpython-digital-in-out

from digitalio import DigitalInOut, Direction, Pull

# digital input/output support

# Initialize the score variable

Score = 0

Ball_Count = 3

num_pixels_Middle = 15

num_pixels_rightMiddle = 15

pixel_pin_rightMiddle = board.GP6

pixel_pin_Middle = board.GP20

#ball Return

SENSOR_PIN = board.GP16 # GPIO pin connected to the sensor's OUT signal

LED_PIN = board.GP15

#neopixrls

pixel_pin = board.GP4

i2c = busio.I2C(board.GP1, board.GP0)

pixels_Middle = neopixel.NeoPixel(pixel_pin_Middle, num_pixels_Middle, brightness=0.3, auto_write=False)

pixels_rightMiddle = neopixel.NeoPixel(pixel_pin_rightMiddle, num_pixels_rightMiddle, brightness=0.3, auto_write=False)

lcd = LCD(I2CPCF8574Interface(i2c, 0x27), num_rows=2, num_cols=20)

lcd.set_backlight(True)

RED = (255, 0, 0) # 100% red, 0% green, 0% blue

GREEN = ( 0, 255, 0) # 0% red, 100% green, 0% blue

BLUE = ( 0, 0, 255) # 100% blue

CYAN = ( 0, 255, 255) # 0% red, 100% green, 100% blue

YELLOW = (255, 150, 0) # 100% red, 55% green, 0% blue

WHITE = (100, 100, 100) # 100% of all colors

LIGHTPINK = (100, 80, 85)

BRIGHTPINK = (100, 60, 70)

BLACK = ( 0, 0, 0) # 0% of all colors (turns the LED off)

#Initialize the target pins

upperRbumper_switches = DigitalInOut(board.GP11)

upperRbumper_switches.direction = Direction.INPUT

upperRbumper_switches.pull = Pull.UP

upperRbumper_solenoid = DigitalInOut(board.GP9)

upperRbumper_solenoid.direction = Direction.OUTPUT

upperRbumper_solenoid.value = False

Rbumper_switches = DigitalInOut(board.GP3)

Rbumper_switches.direction = Direction.INPUT

Rbumper_switches.pull = Pull.UP

Rbumper_solenoid = DigitalInOut(board.GP2)

Rbumper_solenoid.direction = Direction.OUTPUT

Rbumper_solenoid.value = False

Lbumper_switches = DigitalInOut(board.GP22)

Lbumper_switches.direction = Direction.INPUT

Lbumper_switches.pull = Pull.UP

Lbumper_solenoid = DigitalInOut(board.GP5)

Lbumper_solenoid.direction = Direction.OUTPUT

Lbumper_solenoid.value = False

right_flipper = DigitalInOut(board.GP21)

right_flipper.direction = Direction.OUTPUT

right_flipper.value = False

left_flipper = DigitalInOut(board.GP14)

left_flipper.direction = Direction.OUTPUT

left_flipper.value = False

# Initialize the flipper button as an input

rflipper_button = DigitalInOut(board.GP19)

rflipper_button.direction = Direction.INPUT

rflipper_button.pull = Pull.UP

lflipper_button = DigitalInOut(board.GP8)

lflipper_button.direction = Direction.INPUT

lflipper_button.pull = Pull.UP

sensor = digitalio.DigitalInOut(SENSOR_PIN) # create a DigitalInOut object for the sensor pin

sensor.direction = digitalio.Direction.INPUT # set the pin direction to input (we read from it)

sensor.pull = digitalio.Pull.UP # enable internal pull-up; sensor pulls LOW when beam breaks

LED = digitalio.DigitalInOut(LED_PIN) # create a DigitalInOut object for the (infrared) LED

LED.direction = digitalio.Direction.OUTPUT # set LED pin as output so we can turn it on/off

middle_target_switch = DigitalInOut(board.GP26)

middle_target_switch.direction = Direction.INPUT

middle_target_switch.pull = Pull.UP

backright_target_switch = DigitalInOut(board.GP7)

backright_target_switch.direction = Direction.INPUT

backright_target_switch.pull = Pull.UP

backleft_target_switch = DigitalInOut(board.GP27)

backleft_target_switch.direction = Direction.INPUT

backleft_target_switch.pull = Pull.UP

frontleft_target_switch = DigitalInOut(board.GP12)

frontleft_target_switch.direction = Direction.INPUT

frontleft_target_switch.pull = Pull.UP

farbackleft_target_switch = DigitalInOut(board.GP13)

farbackleft_target_switch.direction = Direction.INPUT

farbackleft_target_switch.pull = Pull.UP

Ball_Count_Button = DigitalInOut(board.GP17)

Ball_Count_Button.direction = Direction.INPUT

Ball_Count_Button.pull = Pull.UP

def debounce():

start_time = time.monotonic()

estimated_trigger_time = 5 #time in ms

current_time = time.monotonic()

print("start_time:", start_time, "current_time", current_time)

if current_time - start_time > estimated_trigger_time:

print("checking again")

# event counter for number of beam breaks detected

def color_chase(color, wait):

for i in range(num_pixels):

pixels[i] = color

time.sleep(wait)

pixels.show()

time.sleep(0.5)

def rainbow(wait):

for count in range(256):

for pixel_num in range(len(pixels)):

pixels[pixel_num] = colorwheel((pixel_num + count) % 255)

pixels.show()

time.sleep(wait);

def target_switch_frontleft():

global Score

if (frontleft_target_switch.value == False):

Score += 100

#time.sleep(.1)

print("Score increased by 100")

def target_switch_middle():

global Score

if (middle_target_switch.value == False):

Score += 150

#time.sleep(.1)

print("Score increased 150")

def target_switch_backright():

global Score

if (backright_target_switch.value == False):

Score += 150

#time.sleep(.1)

print("Score increased by 150")

def target_switch_backleft():

global Score

if (backleft_target_switch.value == False):

Score += 100

#time.sleep(.1)

print("Score increased by 100")

def target_switch_farbackleft():

global Score

if (farbackleft_target_switch.value == False):

Score += 175

#time.sleep(.1)

print("Score increased by 175")

def Decrease_Ball():

global Ball_Count

if(Ball_Count_Button.value == False):

Ball_Count-= 1

#time.sleep(.1)

LED.value = True

print(sensor.value)

if sensor.value == False:

debounce()

Ball_Count-= 1

#time.sleep(.5)

print("Ball Count decreased")

def Game_Over():

global Ball_Count, Score

lcd.clear()

lcd.set_cursor_pos(0, 3)

lcd.print("GAME OVER")

time.sleep(3)

Ball_Count = 3

Score = 0

lcd.clear()

return

def theater_chasemiddle(RED, WHITE, WAIT):

for j in range(10): #do 10 cycles of chasing

for q in range(3):

for i in range(0, len(pixels_Middle)-3, 3):

pixels_Middle[i+q] = RED

pixels_Middle[i+q+1] = WHITE

# turn every third pixel on

pixels_Middle.show()

time.sleep(.1);

lcd.set_cursor_pos(0, 1)

lcd.print("ENTERING SPACE")

time.sleep(3.5)

lcd.clear()

#Ball_Count = 3

while True:

#last_time = time.monotonic()

#interval = 3.0 # seconds

#pixels_Middle.fill(BRIGHTPINK)

#pixels_Middle.show()

target_switch_backleft()

target_switch_backright()

target_switch_farbackleft()

target_switch_middle()

target_switch_frontleft()

Decrease_Ball()

lcd.set_cursor_pos(1, 3)

lcd.print("Score: "+ str(Score))

lcd.set_cursor_pos(0, 1)

lcd.print("BALL COUNT: "+ str(Ball_Count))

if Ball_Count <= 0:

Game_Over()

#time.sleep(.2)

LED.value = True

print(sensor.value)

if sensor.value == False:

debounce()

if (rflipper_button.value == True):

print("button not pressed")

#time.sleep(.03)

right_flipper.value = False

# time.sleep(.03)

else:

print("button pressed")

# The button is pulled to ground, so the switch is pressed

right_flipper.value = True

if (lflipper_button.value == True):

print("Left button not pressed")

#time.sleep(.03)

# The input has a pull up, so this means

# the value is True when the button is not pressed

left_flipper.value = False

#time.sleep(.03)

else:

print("left button pressed")

left_flipper.value = True

if (Rbumper_switches.value == True):

print("Right Bumper Switch NOT Pressed")

pixels_rightMiddle.fill(BRIGHTPINK)

pixels_rightMiddle.show()

Rbumper_solenoid.value = False

#time.sleep(.03)

else:

print("Right Bumeper Switch pressed")

Rbumper_solenoid.value = True

pixels_rightMiddle.fill(RED)

pixels_rightMiddle.show()

if (upperRbumper_switches.value == True):

print("Upper Right Bumper Switch Not Pressed")

#time.sleep(.03)

# The input has a pull up, so this means the value is True when the button is not pressed

upperRbumper_solenoid.value = False

#time.sleep(.03)

else:

print(" Upper Right Bumeper Switch pressed")

upperRbumper_solenoid.value = True

if (Lbumper_switches.value == True):

print("Left Bumper Switch NOT Pressed")

pixels_Middle.fill(BRIGHTPINK)

pixels_Middle.show()

Lbumper_solenoid.value = False

#time.sleep(.03)

else:

print("Left Bumper Switch pressed")

Lbumper_solenoid.value = True

pixels_Middle.fill(RED)

pixels_Middle.show()

#time.sleep(.001)

#print("color_chase(BLUE): moves red across the strip")

#color_chase(BLUE, 0.1)

#time.sleep(.01)

#for i in range (0,20):

#lcd.shift_display(.5)

# time.sleep(.35)

#Used for increasing our score by a certain amount

#Bump the score for the next iteration of the loop

#score = score + 100

#increase_score = score + 250

#if (target1_switch.value == True):

#lcd.print("score")

#score = score + 250

#if not target1_switch.value:

#lcd.print("Switch is pressed!")

#score = Score + 250

This code controls the main system of a pinball machine by managing scoring, inputs, and outputs in real time. It uses sensors and switches to detect when the ball hits targets or leaves the play area, then updates the Score and Ball_Count. The LCD screen displays the score and remaining balls, while components like flippers, bumpers, and LEDs respond to player actions and ball movement. The program runs continuously, checking inputs and updating the system so the game reacts instantly. If the ball count reaches zero, a “Game Over” function resets the game. Overall, the code acts as the “brain” of the machine, connecting hardware to logic to create a working game.

This code controls the movement and lighting system of the pinball machine using servos and LED strips. It uses servo motors to move mechanical components such as the Sun, Planet, and two Satellites, rotating them by changing angles between 0 and 180 degrees. At the same time, it controls multiple NeoPixel LED strips, creating lighting effects like solid colors and “chasing” patterns to make the system more visually engaging. The program runs in a continuous loop, switching between movement and lighting animations to simulate active motion. Overall, this code focuses on the mechanical motion and visual effects of the system, helping bring the design to life.

NeoPixel/Servo's

"""CircuitPython Essentials Servo standard servo example"""

import time

import board

import pwmio

from adafruit_motor import servo

import time

import board

from rainbowio import colorwheel

import neopixel

# create a PWMOut object on Pin A2.

pwm1 = pwmio.PWMOut(board.GP10, duty_cycle=2 ** 15, frequency=50)

pwm2 = pwmio.PWMOut(board.GP6, duty_cycle=2 ** 15, frequency=50)

pwm3 = pwmio.PWMOut(board.GP12, duty_cycle=2 ** 15, frequency=50)

pwm4 = pwmio.PWMOut(board.GP0, duty_cycle=2 ** 15, frequency=50)

pixel_pin_left = board.GP2

pixel_pin_right = board.GP3

pixel_pin_Topright = board.GP4

pixel_pin_Topleft = board.GP5

pixel_pin_smallleft = board.GP16

pixel_pin_smallright = board.GP7

pixel_pin_Middle = board.GP15

pixel_pin_rightMiddle = board.GP18

pixel_pin_smallMiddle = board.GP13

pixel_pin_smallMiddle2 = board.GP14

num_pixels_left = 26

num_pixels_right = 26

num_pixels_Topright = 26

num_pixels_smallright = 6

num_pixels_smallleft = 6

num_pixels_Topleft = 20

num_pixels_Middle = 15

num_pixels_rightMiddle = 15

num_pixels_smallMiddle = 10

num_pixels_smallMiddle2 = 10

pixels_left = neopixel.NeoPixel(pixel_pin_left, num_pixels_left, brightness=0.3, auto_write=False)

pixels_right = neopixel.NeoPixel(pixel_pin_right, num_pixels_right, brightness=0.3, auto_write=False)

pixels_Topright = neopixel.NeoPixel(pixel_pin_Topright, num_pixels_Topright, brightness=0.3, auto_write=False)

pixels_smallright = neopixel.NeoPixel(pixel_pin_smallright, num_pixels_smallright, brightness=0.3, auto_write=False)

pixels_smallleft = neopixel.NeoPixel(pixel_pin_smallleft, num_pixels_smallleft, brightness=0.3, auto_write=False)

pixels_Topleft = neopixel.NeoPixel(pixel_pin_Topleft, num_pixels_Topleft, brightness=0.3, auto_write=False)

pixels_Middle = neopixel.NeoPixel(pixel_pin_Middle, num_pixels_Middle, brightness=0.3, auto_write=False)

pixels_rightMiddle = neopixel.NeoPixel(pixel_pin_rightMiddle, num_pixels_rightMiddle, brightness=0.3, auto_write=False)

pixels_smallMiddle = neopixel.NeoPixel(pixel_pin_smallMiddle, num_pixels_smallMiddle, brightness=0.3, auto_write=False)

pixels_smallMiddle2 = neopixel.NeoPixel(pixel_pin_smallMiddle2, num_pixels_smallMiddle2, brightness=0.3, auto_write=False)

#lcd = LCD(I2CPCF8574Interface(i2c, 0x27), num_rows=2, num_cols=20)

#lcd.set_backlight(True)

RED = (255, 0, 0) # 100% red, 0% green, 0% blue

GREEN = ( 0, 255, 0) # 0% red, 100% green, 0% blue

BLUE = ( 0, 0, 255) # 100% blue

CYAN = ( 0, 255, 255) # 0% red, 100% green, 100% blue

YELLOW = (255, 150, 0) # 100% red, 55% green, 0% blue

WHITE = (100, 100, 100) # 100% of all colors

LIGHTPINK = (100, 80, 85)

BRIGHTPINK = (100, 60, 70)

BLACK = ( 0, 0, 0) # 0% of all colors (turns the LED off)

# Create a servo object, my_servo.

my_servo_R = servo.Servo(pwm1)

my_servo_L = servo.Servo(pwm2)

my_servo_front = servo.Servo(pwm3)

my_servo_Sun = servo.Servo(pwm4)

#def color_chase_smallleft(color):

#for i in range(num_pixels_left):

# pixels_smallleft[i] = YELLOW

#time.sleep(wait)

#pixels_smallleft.show()

#time.sleep(0.2)

#ef rainbow():

#for count in range(256):

#for pixel_num_right in range(len(pixels_right)):

# pixels[pixel_num_right] = colorwheel((pixel_num_right + count) % 255)

# pixels_right.show()

#time.sleep(wait);

def theater_chaseright(WHITE, CYAN, WAIT):

for j in range(10): #do 10 cycles of chasing

for q in range(3):

for i in range(0, len(pixels_right)-2, 3):

pixels_right[i+q] = WHITE

pixels_right[i+q+1] = CYAN

pixels_right.show()

time.sleep(.1);

#for i in range(0, len(pixels_right)-2, 3):

# pixels_right[i+q] = BLACK # turn every third pixel off

def theater_chaseleft(WHITE, CYAN, WAIT):

for j in range(10): #do 10 cycles of chasing

for q in range(3):

for i in range(0, len(pixels_right)-2, 3):

pixels_left[i+q] = WHITE

pixels_left[i+q+1] = CYAN

pixels_left.show()

time.sleep(.1);

def theater_chasermiddle(LIGHTPINK, BRIGHTPINK, WAIT):

for j in range(10): #do 10 cycles of chasing

for q in range(3):

for i in range(0, len(pixels_Middle)-3, 3):

pixels_rightMiddle[i+q] = LIGHTPINK

pixels_rightMiddle[i+q+1] = BRIGHTPINK

# turn every third pixel on

pixels_rightMiddle.show()

time.sleep(.1);

#for i in range(0, len(pixels_Middle)-2, 3):

#pixels_Middle[i+q] = BLACK # turn every third pixel off

while True:

my_servo_front.angle = 0

time.sleep(.5)

my_servo_R.angle = 0

time.sleep(.5)

my_servo_R.angle = 180

time.sleep(.5)

my_servo_L.angle = 0

time.sleep(.5)

my_servo_L.angle = 180

time.sleep(.5)

# print("Seting the strip to a solid color")

pixels_Topright.fill(YELLOW)

pixels_Topright.show()

pixels_smallright.fill(BLUE)

pixels_smallright.show()

pixels_Topleft.fill(YELLOW)

pixels_Topleft.show()

pixels_smallMiddle.fill(BRIGHTPINK)

pixels_smallMiddle.show()

pixels_smallMiddle2.fill(BRIGHTPINK)

pixels_smallMiddle2.show()

#color_chase_smallleft(YELLOW)

pixels_smallleft.fill(BLUE)

pixels_smallleft.show()

my_servo_R.angle = 0

time.sleep(.5)

my_servo_R.angle = 180

time.sleep(.5)

my_servo_L.angle = 0

time.sleep(.5)

my_servo_L.angle = 180

time.sleep(.5)

theater_chasermiddle(LIGHTPINK, BRIGHTPINK, .1)

my_servo_R.angle = 0

time.sleep(.5)

my_servo_R.angle = 180

time.sleep(.5)

my_servo_L.angle = 0

time.sleep(.5)

my_servo_L.angle = 180

time.sleep(.5)

theater_chaseright(WHITE, CYAN, .1)

my_servo_R.angle = 0

time.sleep(.5)

my_servo_R.angle = 180

time.sleep(.5)

my_servo_L.angle = 0

time.sleep(.5)

my_servo_L.angle = 180

time.sleep(.5)

theater_chaseleft(WHITE, CYAN, .1)

my_servo_R.angle = 0

time.sleep(.5)

my_servo_R.angle = 180

time.sleep(.5)

my_servo_L.angle = 0

time.sleep(.5)

my_servo_L.angle = 180

time.sleep(.5)

#pixels_left.fill(WHITE)

#pixels_left.show()

#pixels_right.fill(CYAN)

my_servo_Sun.angle = 180

time.sleep(.5)

Final Video

Overall:

This project was an interesting challenge to close out the Engineering pathway class, especially working as a group of three with many components and requirements. We had to complete more complex parts like the flipper, bumpers, and ball return system, as well as simpler components like the NeoPixels and servo system. Overall, this project gave me the opportunity to test and apply my engineering skills in a hands-on and engaging way.

Reflection:

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

Compared to other projects I think the pinball required a lot of extra time in class especially because we couldn't really take it home, it also required a lot even more communication seeing as we were a group of 3. The skittle sorter project we completed last year was pretty hard, but in comparson it wasn't as hard to code and assemble, we used only card board and simple logic to complete it along with being able to take it home. This project required us to be very responsible and forward thinkers, from the amount of trial and error and troubleshooting we had to be patient and ready to fix something quickly.

How did it feel to complete this project.

To complete this project it felt amazing when we were able to finish a component, and little frustrating to have something break or not work. Overall I felt proud in the end of all the hard work put in over the this last year in Engineering. At Space is the new place we had many people try the game and complimented the functionality of the board, which honestly made me feel a sense of relief knowing we were able to make to the end without to many problems,

What are you most proud of about your project?

The part of my project that im most proud of is the Bumpers, mainly because of smooth the process was for the most part. We were told this was one of the harder components in the project but, me and my group members helped eachother out. Whether is was 3d printing, code, or assembly, we all completed Bumpers that were super functional and effective. We also made 2 of our Neopixels react to 2 of our bumpers which added a fun look to the game.

Thoughtfully describe the technical skills that you have gained throughout this project.

Through the pinball project, I gained strong technical skills in mechanical design, electronics, and programming. I learned how to build and align moving components like bumpers, flippers, and ball return systems while minimizing friction and ensuring stability. I also worked with wiring, sensors, and a microcontroller to connect inputs like switches to outputs like solenoids, servos, and NeoPixel LEDs. Using Python, I programmed the system to track score and respond to actions in real time. This project also improved my troubleshooting skills, since I had to fix both mechanical and coding issues. Overall, it helped me understand how hardware and software work together to create a functional system.

Thoughtfully describe the softskills you have developed/improved throughout this project.

Through the pinball project, I developed and improved several important soft skills, especially teamwork, communication, and problem-solving. Working in a group of three required us to divide tasks, stay organized, and make sure everyone was contributing to different parts of the project. I had to clearly communicate ideas and explain problems when something wasn’t working, which helped us fix issues more efficiently. I also improved my adaptability and patience, since we ran into challenges that required us to rethink our design and try new approaches. Time management was another key skill, as we had to balance multiple components and meet deadlines. Overall, this project helped me become a better collaborator and a more effective problem solver in a team environment.