Design

Functional Goals for Robot:

Simple
Reliable
Accurate

Our project had these three goals in order to ensure we focused our time on the areas of our robot that would have the greatest effect in the competition. We wanted our robot to be simple so that it was less likely to break during the competition and easy to debug and fix when there were issues. We wanted it to be reliable because that is the best way to ensure we could score the most points in the competition. If we can keep catching and throwing reliably then even if we aren't highly accurate or powerful we will still be able to get points during the competition. Finally we wanted our robot to be accurate so that we could score even more points during the competition. The accuracy of our robot comes from its simplicity and dependability. These three goals are how we approached designing and building our robot and what we fell back to when unsure what direction to more forward with.

Initial Design:

CAD Initial Drawing with Measurements

CAD Initial Drawing with Part Descriptions

This design utilizes a wind vortex tunnel system to direct the ball down to the firing mechanism.

While the ball is being loaded, the Kinect or the operator locates the target. The launching mechanism then adjusts the angle and direction of the launcher while also compressing a spring to the desired tension for the distance of the target.

Once the tension has reached the appropriate tension and the launcher is angled correctly, the spring is released and the pall is propelled out towards the target.

Final Design:

Final Design of the Robot

In the final design we ended up changing several parts from our initial design.

We decided to keep with the wind vortex system. Rather than have the fans be attached to the funnel with 3D printed brackets in order to have the fans be angled to make the vortex function, we decided to just have the fans directly attached to the funnel since changing the angle of the fans didn't end up creating enough of a vortex to make a difference in the ball being drawn in.

We decided to use a GoPro instead of a Kinect since the remote access was simpler using already existing materials used with drones.

We chose a Teensy 2.0 instead of a full computer or BeagleBone, since it was capable of our power distribution and full motor control needs.

We chose a flywheel design instead of our spring piston system because the piston turned out to be insufficient to throw the ball.

We decided to perform all tasks with direct control, since the game tasks failed to benefit from automated processes.

Functional Flowchart

Mechanical Design:

Initial Firing Mechanism: Piston

The initial firing mechanism was designed to pull back a piston and then release it, punching the ball in the desired direction. Shown on the left, while we produced a variety of improvements and revisions to our design, the final result was unable to hit the ball the required distance, and was deemed too unreliable for our application. instead, we opted to use a flywheel design, detailed below.

Top: Image of Final Piston Design

Bottom: CAD of the 3D Printed Pieces of the Piston Design

Final Firing Mechanism: Flywheels

The second method we employed was successful. The two motors spin in opposite directions to create a net rapid displacement of the ball between two spinning wheels. This throws the ball out in the direction where it was pointing. The wheels were spaced just wide enough apart to ensure the ball would be gripped tightly as it was pulled through. This was mounted on the same turntable that previously held the piston assembly. This approach was efficient, easy to control, and less unstable than before. We also added a servo with a long rod attached, that would rotate 90 degrees slowly, rolling the ball from the back of the apparatus into the flywheels.

3D Printed Mounting Brackets and Wheels

Top: Video of Working Flywheel Firing Mechanism

Bottom: CAD Representation of Flywheel Firing Mechanism

Catching Design: Funnel and Fans

For the catching component of our robot, we used laser-cut cardboard triangles, arranged into an octagon shape, to achieve the largest possible size of the limited 3-feet diameter for the competition. We designed this shape in SolidWorks, ensuring the depth of the final funnel would prevent bounce-back.

We included circular holes to fit the size of CPU fans of the standard 120 mm size. The idea to include these fans was chosen to enable air vortex formation, to better draw the ball into the funnel once thrown. While the final airflow was less than desired, the color capabilities of the fans enabled light signaling during catch.

The base for the entire robot was a 2x2" wooden slab with four wooden posts at each corner upon which the funnel was placed. This arrangement positioned the funnel directly above the turntable for connecting to the flywheels.

Powered Funnel and Fans

Turntable and Positioning

The turntable consists of two rotating plates connected with L-brackets. The shape of each was laser-cut from designs created from the free solid-works files of the turntable components, found on the Vex Robotics website.

Aiming System Turntable Gears

Electrical Design:

Catching Design: Fans

For the catching components we used a funnel to catch the ball. In an attempt to make it so that the ball would be easier to catch, we decided that the addition of the fans in order to create a vortex to suck the ball in faster. The fans that were used are two different types of computer fans. The larger of the fans, seen right, also have RGB leds that gave us the option to have the fans change colors to symbolize what stage the robot is in, confuse the opponent of the robot, and as a HRI feature. These fans came with a power regulator, seen below, that made it so that we were able to run all of the power for the fans through one system that would be attached to the power supply.

Top: RGB Fans Used to Create Wind Vortex

Bottom: Power Control Unit for the Fans

Firing Mechanism: Servo Motor

The servo motor was used to feed the beach ball into the flywheel to be fired. The servo motor was used in order to be able to have finer control of how the ball is feed into the flywheels. We were able to make it so the ball was slowly feed into the flywheels with the robot aimed while not having the risk of the servo arm be feed into the flywheels and then have a unwanted projectile shot from our robot.

Servo Motor on the Left with Yellow, Red, Brown Control Wires

Firing Mechanisms: Flywheel Motors

The main portion of the firing mechanism is the flywheel, it is comprised of two Sunnysky Outrunner Brushless motors that were taken from a drone that the team owned. This combined with the motor controllers, that also came from the drone, made it so that once the printed wheels are attached they will be able to spin up with limited vibration that could cause the robot to come apart and malfunction.

Sunnysky Outrunner Brushless Motor Attached to Mounting Brackets for Firing Mechanism

Control System: Teensy 2.0 and RC Controller

The brain of the robot was a Teensy microcontroller. This was connected to an RC controller receiver to allow the operator to control the aiming mechanism and the servo to push the ball into the fly wheels. The Teensy read the PWM signals from the RC receiver and then wiggled IOs connected to an H-Bridge in order to provide power to the two motors and allow them to spin both directions. It also also controlled the servo motor via a PWM output to push the ball into the firing mechanism.

RC Controller Used to Control to Robot

Top: Teensy 2.0 (left) Attached to Breadboard with Connections to H-Bridge, RC traciever, and motors

Bottom: RC Traciever with Antenea (left) and Speed Controller for Brushless Motors

Aiming Mechanism: Motors

Two brushed DC motors where attached to the turntables in order to aim the firing mechanism of our robot. These motors were controlled by a H-Bridge connected to the Teensy and supplied 5 volts to the motors. The motors are rated up to 12 volts but the motors moved too quickly and so we dropped the voltage to 5 so we had more control over aiming the robot.

H-Bridge to Use Motors in Both Directions

Turntable Aiming Mechanism with Brushed Motors

Vision System: GoPro and Transceivers

The vision system consisted of four key parts: GoPro, video transmitter, video receiver, and a small video screen. Together these parts allowed us to see in real time what our robot was aiming at as well as when someone through a ball into our robot. The components were all off the shelf parts used in drones and were supplied by a team member who had them lying around. We chose this approach because it was simple, reliable even in a saturated RF environment like Kelly's Atrium, and something we already owned.

Video Receiver with Screen Attached on Top

Top: GoPro (left) with Connecting to Video Transmitter and Lipo Battery pack (right attached with tape)

Bottom: GoPro Vision System Attached to Mounting Bracket of Flywheel Firing System

Power System: Power Supply

To power our robot we decided on using a power supply unit for an old desktop computer. We thought this was a good idea because it provides high amperage outputs at several different voltages. It has 12v, 5v, 3.3v, and -12v but we only ended up needing 12v and 5v. It was very simple to wire up our robot to the PSU and it only needed slight modification in order to get working properly. A team member had several of these lying around and it made sense to use this instead of several different voltage regulators.

Computer Power Supply

Software Design:

Teensy Software:

We took advantage of the fact that a Teensy could be programmed via the Arduino IDE. This allowed us to develop quickly and efficiently. The took about an hour or so to write and is very simple. After some quick googling I found some example code on how to read PWM inputs on a Teensy. I basically copied and pasted that code three times for our three inputs and then wrote a very simple function to turn on an H-Bridge depending on the value of the PWM input. If it was below a threshold the motor turns one way if its above a higher threshold the motor turns the other way. If its in between then the motor turns off. This made it very simple to control the direction of the robot allowing us to focus on aiming rather than confusing controls. The final piece was controlling a servo to push the ball into the firing mechanism and this was also trivial to do thanks to Arduino's built in servo library. I just tell it which pin the servo is connected to and the angle I want the servo to move to and it does everything else for me.

Github Link for Robot Code

Google Sites

Report abuse