The beggining:
There were many designs to choose from while making the prototype. From a “happy time” recycling truck, to robotic arms sticking out of the truck that would sort the trash, in the end the multi-arm truck that could carry trash and recyclables was selected.
Figure 1: Truck brainstorming idea
This trucks idea was to collect each type of recyclables separately to keep the recyclables separate so the factory had less sorting to do.
Through the design process, we’ve decided to limit the number of arms to two; one for trash, the other for recyclables. This removes the needs for separate bins for each type of trash, while still maintain the use of one truck for recycling and trash.
Modeling (prototype):
The prototype was modeled to work on a rail system. The setup included a servo holder and arm to simulate load pick up.
Figure 2: Solidworks assembly of prototype.
After finally designing and printing some 3D parts, the assembly above is made. The prototype is made of one propeller and one arm which is attached to a servo. The servo is held down by a specially designed servo holder. (NOTE: the servo is missing due to the inability to find a servo in the assembly; the servo goes between the large fork like arm and servo holder that sits on the back left of the image above)
Figure 3: Drawing of prototype
The prototype comes in at around 10 inches long and a half foot wide & tall. This design was made to be small to allow the truck to fit into even the smallest alleyways.
Figure 4: Exploded view of prototype.
The prototype consists of many materials. The large rectangle and support arm make the “shell” of the vehicle. The 90-deg bracket holds the shell together and the motor mount clip holds the motor to the front of the prototype. The prop 3inch is used to propel the vehicle forward/backwards. The Arduino board is the brain of the vehicle. The servo holder holds the servo in place. The arm is used to simulate the arm of what the arm of the truck would use.
Figure 1: Prototype built
This real life protype used one front end propeller to go forward and backward, and used a servo to retract and raise the claw (video below).
Video 1: Arm claw in action (no audio).
Coding:
The code used is as followed:
void myCode()
{
//----------------------------------------------------------------------------------------
// myCode();
//
// This is the tab where student programming is done.
// A list of available function calls are listed in detail under tab "00_Student_Functions"
//
// Note:
// (1) After running your program do not turn the controller off, connect the controller to a computer, or
// push the reset button on the Arduino. There is a 13 second processing period. In
// post processing, data is stored and battery recuperation takes place.
// (2) Time, current, voltage, total marks, forward marks, and backward marks traveled are recorded approximately
// every 60 milliseconds. This may vary depending on the vehicles operational tasks.
// It takes approximately 35-40 milliseconds for each recording. Thus when programming,
// code complexity may not be beneficial.
// (3) Always comment your code. Debugging will be quicker and easier to do and will
// especially aid the instructional team in helping you.
//----------------------------------------------------------------------------------------
// Program between here-------------------------------------------------------------------
// Run all motors at a constant speed of 35% power for 3 seconds
int x=0;
while (x < 41) {
motorSpeed(1, 35);
x = getForwardCounts();
}
pauseFor(1);
motorSpeed(1, 0) ;
pauseFor(3);
rotateServo(0);
pauseFor(2);
rotateServo(90);
pauseFor(2);
rotateServo(0);
pauseFor(2);
int x2=0;
while (x2 < 41) {
motorSpeed(1, -38);
x2 = getBackwardCounts();
}
pauseFor(1);
motorSpeed(1, 0) ;
pauseFor(3);
rotateServo(0);
pauseFor(2);
rotateServo(90);
pauseFor(2);
rotateServo(0);
pauseFor(2);
//pause all
motorSpeed(4,0);
// And here--------------------------------------------------------------------------------
} // DO NOT REMOVE. end of void myCode()
A little breakdown of the code used is as followed:
Part A: Moving forward and backward.
int x=0;
while (x < 41) {
motorSpeed(1, 35);
x = getForwardCounts();
}
pauseFor(1);
motorSpeed(1, 0) ;
pauseFor(3);
The above code sets up the prototype to move forward. The variable x is defined at zero and a whiel statement is called to make sure the protype moves forward until the getForwardCounts from the light detector wheel counts to the number in the while statement. It will then go forward at 35% until it hits 40 counts forward. The same code is used as the backup, except with a negative motor speed to allow for backing up, and a slight power increase to account for the need for more power when pushing instead of pulling. The pauses are there to allow the machine to stop long enough to simulate stopping for pick-up.
Part B: Arm claw simulation
rotateServo(0);
pauseFor(2);
rotateServo(90);
pauseFor(2);
rotateServo(0);
pauseFor(2);
After the prototype stops, the arm claw is then adjusted to the up right position to allow for accurate positioning while not in use. After such, it lowers, picks up trash (simulated), then raises back up to fill the truck. This is done each time it stops. This does NOT happen at the initial start up location.
Results:
Standards:
Speed: 0.2 – 0.4 meters per second
For speed we wanted something slow enough to act like it’s going through small suburb streets, and not too slow to the point it doesn’t get through effectively. A speed of .2 meters per second at slowest and and .4 meters per second at fastest was chosen for the prototype.
Stopping distance: 25 inches — 5 inch deviation allowed
For stopping distance 25 inches was chosen as realistically the scaled model would need to stop very often. We allowed for a 5 inch deviation as getting a purely accurate 25 inch stop would be hard due to the lack of brakes and inconsistencies with the rail produced.
Arm claw: Goes down and up each stop (not including initial startup).
Arm claw simply was there to simulate the arm the truck would carry and use to automatically pick up trash bins. Due to limited materials, only one arm was able to be simulated.
Final results:
Speed:
Figure 5: Test results of the final distance vs time.
NOTE: This is only of a test forward. Backwards was not included due to random holes in recovered analysis data.
Based on the data above and the data analysis tool, the prototype, when moving, went a little over .2 meters per second.
Distance:
The average distance forward was 25.1 inches forward and the average distance backwards was 21.2 inches backwards. This average was taken based on the data analysis tools reading of our last three attempts using the same code.
Arm claw:
The arm claw could not be recorded via analyzing tools, so we simply saw what happened each stop. A total of two stops were produced during the trial and each time the arm did go down and back up. The testing was successful!
System model:
The real life model would be able to do these things but to a larger extent. First off, it would drive like a normal, everyday garbage truck by a hired driver. The machine will be able to stop on a dime and pick up both recycaling and trash bins at the same time. A map of what a normal route would look like its displayed below:
Figure 1: mock up map route.
The route would consist of following the red arrows around the perimeter of the suburb, then proceed to zig-zag through what it missed. The black arrows indicate the return route where it will pick up the remaining streets trash and recyclables and leave the suburb to go deliver the trash to the plant.
There at the plant the truck will be able to empty each side separately as to not mix trash and recyclables together.