You are on page 1of 15

Project 3.3.

Marble Sorter Report
Nick Maughan
POE - 3rd Block
Date - 3/29/16
Group Members:
Christian Smith
Jake Hebert

Design Problem
Problem: The National Recreation Park Association has asked your team to develop a
solution to a growing problem in their parks. The association has placed dumpsters for
recyclable material throughout the parks. They have a sorting facility; however, they
need the device that will sort the recyclable material.
Design Statement: Design, model, and test a device that will separate recyclable
Constraints: The process must be fully automated and must use one VEX kit or other
approved materials. Must separate mixed up materials which include steel, plastic,

wood, and aluminum.(can not line them up in a specific order). Marbles must be under
control during the process and must include four different marbles(steel,plastic,wood,
and aluminum marbles) with a total of sixteen. The process can take two minutes

Brainstorm Idea

The marble stops at the gate and is scanned by the light sensor and line follower. The rotating
gate moves based on values the sensors receive and the rising gate lifts. The magnet will pull
steel marbles away from the other marbles and cause them to roll down another ramp.

Decision Matrix




























Our criteria included hardware difficulty, code difficulty, complexity, time, and success
probability. We chose criteria mainly focused around the complexity of the idea and the
time it would take to build the project. These criteria seemed most important to us
because the biggest constraint in this project was time, and more complex ideas
generally would take longer and have a higher chance of failure.
We decided to rate our criteria from a scale of one to four (four being the best),
and then we came to a consensus on each of the different blocks of the decision matrix
and then totaled them up. Jake’s idea was the least complex overall and ended up with
the highest score.

Final Design Solution

The marbles are put into a funnel at the top of the ramp, then they roll down to
the first solenoid which stops them from passing. The solenoid then lifts up, allowing the
marble to pass onto another solenoid which holds it up while it is scanned by the line
follower. If the line follower detects the marble as wood, the wheel pushes the marble
away into a cup. If the line follower detects the marble as steel or plastic, the solenoid
retracts and the tank track moves left. If the line follower detects the marble as
aluminum, the solenoid retracts and the tank track turns moves right.
We chose this idea (Jake’s) because it would probably take a moderate time to
build and was the least complex. We believed the chance of success with this idea was
the highest. The idea meets all of the criteria and is easy to understand as well. The
code and the hardware difficulties were about the same according to our decision

matrix, meaning that we would be able to make steady progress and we had the
abilities to complete the build.

Design Modifications
The most major design modification we made involved increasing the stability of
the system. In our original design, there was nothing holding the separate parts of our
marble sorter together, this led to complications with the spacing of the tank track and
the line follower system. In order to increase the stability and consistency of our design,
we added a base plate which we bolted all of the separate parts of our project onto. This
gave the machine a more consistent and clear spacing between the tank track and the
line follower system.
Another major design modification was the removal of our electromagnet idea.
We attempted to put the electromagnet next to the tank track hoping that it would be
strong enough to pull off the steel marble and cause it to land into another cup. This
idea didn’t work, and we decided to use permanent magnets. This involved adding
another ramp in which the plastic and steel marbles would both roll down from off the
tank track. We attached two cups to the bottom of the ramp, one with permanent
magnets which were able to pull the steel marble away from the plastic marble cup.
We also removed our two solenoids from the design idea and replaced them with
a wheel to use as the first gate and a rotating platform to use as the holding point for the
marbles being scanned by the line follower. We made these modifications because the
solenoids didn’t seem like they could be implemented in a feasible amount of time, and
we were rushing to begin testing with the code and hardware together. These two
modifications were much easier to implement than the solenoids and sped up our
testing process considerably.

Final Design

Our machine sorted 2 steel marbles and 2 wood marbles. The total number of marbles
that went through the process was 16, all of them were able to make it through the gate
onto the platform, though they were not always sorted correctly. It took a little over a
minute to complete the entire process.

ROBOTC Program
#pragma config(Sensor, in1,
#pragma config(Sensor, in2,
potentiometer, sensorPotentiometer)
#pragma config(Sensor, in3,
#pragma config(Sensor, dgtl1, limitSwitch,
#pragma config(Sensor, dgtl2, bumpSwitch,
#pragma config(Sensor, dgtl3, quad,
#pragma config(Sensor, dgtl5, sonar,
#pragma config(Sensor, dgtl7, Switch,
#pragma config(Sensor, dgtl12, green,
#pragma config(Motor, port1,
tmotorVexFlashlight, openLoop, reversed)
#pragma config(Motor, port2,
#pragma config(Motor, port3,
#pragma config(Motor, port5,
#pragma config(Motor, port6,
#pragma config(Motor, port9,
tmotorServoStandard, openLoop)
//*!!Code automatically generated by 'ROBOTC' configuration wizard
Project Title: 3.3.1 Marble Sorter
Team Members: Christian Smith, Jake Hebert, Nick Maughan
/*Task Description: The marbles are dropped through the funnel and stop at
the gate. The gate allows one
marble through at a time to the flip gate. The line follower attached to
the flip gate will detect
if the marble is wood or not. If wood, the flip gate will flip right into
the wood cup. If aluminum,
the flip gate will flip left and the train track will move backwards into
the aluminum cup. If
steel or white plastic, the flip gate will flip left and the track will
move forwards and drop onto
another track. The marble will roll down the track and a magnet at the end
will pull the steel marble
into a cup while the white plastic will drop into a separate cup. This
process will repeat until all the

marbles have been sorted.
float marble;
//Marble variable
float wood;
marble variable created
float plastic;
//Plastic marble
variable created
task trainTrackMovement
//Moves the train track
startMotor(rightMotor, -35);
//Starts right motor
ck moves for 2 seconds
//Right motor stops
ts 4 seconds before starting again
task oppositeTrainTrackMovement
//Moves train track opposite way
startMotor(rightMotor, 35);
//Starts right motor

ck moves for 2 seconds
//Right motor stops
ts 2 seconds before starting again
task gateMovement
//Gate moves in
int i = 0;
int variable i
//While i
is less than 1
ts one second

//i goes up 1
//Repeats forever
//Gate starts at 20 speed
ts .3 seconds
//Gate stops moving

ts 5 seconds
task flipMarbleRight
//Drops marble only into
wood cup
setServo(servoMotor, 127);
//Sets servo to FAR RIGHT position
ts .5 seconds
setServo(servoMotor, 30);
//Sets servo back to default
ts 4 seconds
task flipMarbleLeft
//Drops marble onto
train track always
setServo(servoMotor, -127);
//Sets servo to FAR LEFT position
ts .5 seconds
setServo(servoMotor, -30);
//Sets servo back to default position
ts 4 seconds

task main()
//Main task
//Calls gateMovement method to
ts one second
//Repeats forever
ts 4 seconds
if(SensorValue(lineFollower) <200 &&
//If line follower detects
marble = wood;
//Marble equals
//flipMarbleRight method called to begin
else if(SensorValue(lineFollower) <=700 &&
SensorValue(lineFollower)>=200)//If line follower detects plastic
marble = plastic;
//Marble equals
//flipMarble method called to begin

//oppositeTrainTrackMovement method called to begin

//Else...(If not either of the first two)
//flipMarble method called to begin
//trainTrackMovement method called to begin

Design Process
1. Define the Problem
We reviewed over the constraints and criteria, and determined that we needed to
create a marble sorter capable of sorting 4 different material marbles up to 16 total
2. Generate Concepts
Each of us brainstormed solutions to the problem after looking over the marbles
and testing various properties of them.
3. Develop a Solution
We all created detailed sketches of our personal brainstorm ideas to present to
the group. We then put our three final sketches into a decision matrix and came to a

consensus on which of the 3 was the best. We then drew a final drawing of the chosen
brainstorm idea.
4. Construct and Test a Prototype
We created our design using the vex kits, and performed numerous tests to try to
improve the design and repeatability of the prototype. We tested our prototype many
times during the construction phase and then had a final test in an informal
5. Evaluate the Solution
Our solution was not very effective overall, it took longer than anticipated to
create the machine, and it was very inconsistent and had numerous issues throughout
the design process. We evaluated our solution in our report and in our various progress
reports in class. We determined that the design wasn’t adequate in solving the problem,
and needed to be more consistent.
6. Present the Solution
We added our machine to our engineering portfolios and also presented our
solution in an informal presentation in class.

Team Evaluation
Jake: Jake was mainly involved in creating the hardware of our solution, he did a good
job putting the pieces together, and overall did his share of the work. Jake designed the
initial ramp used, and created the flipping mechanism for the marbles with the line
follower on it. Jake came in early multiple times to help work on the project and try to
meet the deadline.
Christian: Christian wrote the code for our machine, he did a good job trying to meet the
needs of the hardware as it evolved over time. Christian came in early multiple times to
test the marble sorter and try to fix the timing of the mechanisms so that the marble
sorter could have greater repeatability
Nick (myself): I mainly helped Jake with the hardware, I brainstormed ideas to solve our
magnet problem, and helped create the ramp that we ended up using. I also helped

shuffle the various parts of our design around to try to increase the consistency of the
mechanisms in conjunction with each other. I also came in early to try to sort out the
problems we were having with our project.

a. What would your team do differently with your design solution and why?
We would add supports to the flipping mechanism and bolt down the tank track to make
the solution more stable and more consistent so that it would be able to test as many
marbles as needed without falling apart. Our current machine would start to fail and
send marbles in random directions due to issues with the spacing and stability of the
different parts of the machine. (tank track, marble flipper)
b. What was the most challenging aspect of this design problem?
The most challenging aspect of the design problem for us was the stability of the
system. Our design made small shifts in position after each marble had gone through
the system which caused the next marble to be read wrong by the line follower or fall off
the machine. Timing issues involved with the code and hardware meshing poorly also
contributed to this instability.
c. What did you learn?
I learned that stability and consistency is key when it comes to testing and improving a
design so that it will succeed in final testing. I also learned that it is essential that the
code and hardware of a design are in sync with each other and work well together.

d. What were some of the challenges of working in a design team?
One of the major challenges was clear communication of ideas between group
members. Sometimes ideas would be communicated poorly, and cause issues involving
code and hardware compatibility.