Final Report - Claymore - Grand Valley State University

ROBOTIC WORLD CUP
Final Report
Team 6:
Ben Davison, Cody Holstege, Travis Knoper,
Greg Loveland, Michael Olson, David Santellan
EGR345 Dynamic Systems Modeling & Controls
Dr. Nael Barakat and Dr. Hugh Jack
December 4, 2006

Table of Contents
Section page
Executive Summary 2
1. Design Description 3
1.1 Drawing Summary 3
Figure 1.1 3
Figure1.2 3
1.2 System Block Diagrams 4
Figure 1.3: Block diagram of control system for offensive robot. 4
Figure 1.4: Block diagram of control system for defensive robot. 5
1.3 Description of Control Scheme 5
Figure 1.5: Block diagram of the general system architecture. 5
1.4 Flow Charts 6
1.5 Schematics 7
1.6 Calculations 7
1.7 Projected Budget, Weight Inventory, and BOM 8
2. Test Results 8
2.1 Simulation Results 8
2.2 Performance Testing 9
2.3 Results of Formal Tests 9
2.4 Comparison of Overall Score Estimates 10
3. Conclusions 11
4. Recommendations 12
Appendix A – Drawings 13
Appendix B – Electrical Schematics 28
Appendix C – Calculations 31
Appendix D – Receipts and Cost Validation 35
Appendix E – C Programs 44
1

Executive Summary
Two robots were designed to compete in a robotic foosball tournament. One
robot was designed to defend three goals spaced evenly on one side. The other robot was
designed to launch practice golf balls past the opponents’ two robots and into one of their
goals. The robots had to measure less than 12 inches in their longest dimension, and
could not extend past the overhead guide rails. Robots were graded based on weight,
cost, build quality, theory quality and points scored by both teams. Both robots
functioned as designed and competed in the EGR101 versus EGR345 competition.
The robots were constructed using aluminum. The group decided on a thin plate
chassis with angled supports to secure the robots to the trains. The defensive robot was
designed to guard our three goals. This was accomplished by tracking the position of the
opponents’ offensive robot and mirroring its movement. The offensive robot used an air-
cannon to fire the practice golf balls. The robot takes as input the position and velocity of
the two opponent robots and calculates the precise time to fire.
2

1. Design Description
1.1 Drawing Summary
Figure 1.1: Isometric view of offensive robot
Figure 1.2: isometric view of defensive robot
3

From Figure 1 and 2 it can be seen that the design approach was to minimize the
material used in the construction to reduce the cost and weights of the robots. Wherever
possible, material was cut out to save weight. The uprights were designed as the
strongest part of the robot because they are expected to take the largest load. The design
of each robot is the same, with the exception of a barrel on the offensive robot and a net
on the defensive robot, this is to make the manufacturing of the robots easier and cheaper.
More detailed Pro-E drawings can be viewed in appendix A.
1.2 System Block Diagrams
Figure 2.1 shows a block diagram for the offensive robot. A setpoint generator
will be combined with a proportional gain controller using the opponent’s position as
feedback for proper target acquisition.
Figure 2.2 is the block diagram for the defensive robot. This control system will
track the opponent’s offensive robot in order to defend against incoming projectiles.
Figure 1.3: Block diagram of system architecture for offensive robot.
4

Figure 1.4: Block diagram of system architecture for defensive robot.
1.3 Description of Control Scheme
Figure 2.3 shows a block diagram for the general system architecture for both
robots. Electrical components include the ATMega32 board, an L293D push-pull 4
channel driver (H-Bridge), and the driving motor. A DB-25 connector will supply
positional feedback for the opponent’s robots.
Figure 1.5: Control Block Diagram.
5

1.4 Flow Charts
Flow charts were created to map the desired function of the C programs which
can be seen in Appendix E. Flow charts for the defensive and offensive controller
programs can be seen in Figures 1.6 and 1.7 respectively.
Figure 1.6: Flow chart of defensive controller program.
6

1.5 Schematics
Figure 1.7: Flow chart of defensive controller program.
For ease of manufacturability, both robots used very similar wiring layouts. The
schematics for both of these layouts can be seen in Appendix B.
1.6 Calculations
Using Kinematics equations, the required velocity of the ball was determined to
be 29.4 ft/s. This would allow the ball to cross the playing field in 0.225 seconds with a
7

maximum height of 4 inches above where it is fired. Robot velocities were calculated for
several different gear ratios. This information was used to choose the proper gear ratio.
The selected gear ratio was 41.7:1 which was capable moving the robot between 1.06 ft/s
to 1.32 ft/s. All of the calculations used to obtain these values can be seen in Appendix
C.
1.7 Projected Budget, Weight Inventory, and BOM
All of the supplies which were not directly purchased from a supplier were
researched and priced. The final price for both robots was $121.68. The mass of each
part on the robot was measured, the total mass came to 0.593 kg for the offensive robot
and 0.498 kg for the defensive robots. All of the researched prices, receipts for purchased
products, and the weight inventory can be seen in appendix D.
2. Test Results
2.1 Simulation Results
Simulations were conducted to determine motion of the robots prior to placing
them on the playing field. Using proximity sensors, the actual competition playing field
is to supply the robots with 4 analog signals ranging from 0 to 5 volts, depending on the
robot’s distance from the sensor. The greater the distance between the robot and the
proximity sensor, the greater the voltage supplied, and the greater the analog signal.
In order to simulate position data, variable power supplies were used to generate
analog position feedback. The output voltage on two power supplies was varied between
0 and 5 volts and fed into port A of the ATMega32. The robot controllers took advantage
of the ATMega32 onboard analog-to-digital converter, and the simulated position voltage
was correctly converted on 2 analog input channels. As expected, the controller program
output motor voltage in an attempt to track the enemy and mirror its simulated position.
With the exception of frequently overshooting the enemy’s simulated position, the
controller program correctly tracked and mirrored its attacker. Analysis of the controller
program showed a tendency for the robot to decelerate at the same rate as it would
accelerate, causing the robot to overshoot its desired position. Code was added which
8

allowed the robot controller to monitor its position more accurately, decreasing the
amount of overshoot.
2.2 Performance Testing
Several tests were performed before conducting the individual in-class tests. One
of the first tests was to compare the performance of two gearboxes—the Tamiya High-
Speed Gearbox and the Tamiya High-Power Gearbox. The gearboxes were tested
by supplying each with a range of voltages and weight loads, then measuring the
resulting velocities. It was observed that the high-speed gearbox indeed had higher
velocity, but could not handle the required weight loads. However, the high-power
gearbox met our velocity requirements throughout the voltage range, and was also
capable of handling the expected weight loads.
Once a gearbox had been chosen, the robot was tested on the track. It was
observed that the robot bound with the truck and could not move. This was fixed by
enlarging the slot that the pins go through.
The barrel was tested by supplying 85 psi through a ¼” air hose. Initially, the ball
did not have enough velocity to cross the playing field. The barrel was modified by
covering the holes with electrical tape and retested. This modification gave the ball
enough velocity to cross the field and score a goal.
Several tests were performed on the program. Once the program was functioning
properly, there were still several calibration problems. The defensive program was
modified to stop the motor upon reaching the desired destination so that it did not
overshoot. The offensive program was calibrated to find desired shooting positions that
were not blocked by the opposing team’s defensive robot.
2.3 Results of Formal Tests
There were three main in-class tests of the robot’s function. For the first test, the
base of the robot was completed and the robot’s ability to move on the track was
demonstrated. For the second test, the mechanical aspects of both the offensive and
defensive robots were completed. Both robots traversed the path without binding on the
truck and the offensive robot fired a ball with sufficient velocity to score a goal. The goal
9

of the final in-class test was a test of the defensive robot’s control system. The defensive
robot was able to track the truck on the opposite side of the playing field using signals
sent through the DB-25 connector.
Several problems with the robots were noted from these tests. One of the first
significant observations was that when 5 volts was supplied instantaneously to the motor,
the motor produced so much torque that the front wheels lifted off the track causing the
truck to bind. The problem was fixed by ramping up the voltage to the motor.
A second observation was that the defensive robot tended to overshoot its desired
location when tracking the opposite truck. It was determined that this was due to large
acceleration caused by a function in the code. The function not only caused the robot to
accelerate when beginning to move but also caused the robot to decelerate when
stopping, in turn causing the robot to overshoot its desired location. This was fixed by
eliminating the robot’s ability to decelerate and changing the code so that, slightly before
reaching its desired location, the voltage was completely shut off.
2.4 Comparison of Overall Score Estimates
Where
The scoring from the competition will be calculated with the following equation:
S = Shots blocked by opponent
H = Shots scored
C = Cost of both robots
B = Build Quality
T = Theory rating
M = Mass of both robots
S
2
H
C
4
−2
80 −B
−T
⎛ M ⎞
( 4)
( 10)
( 10)
⎜ ⎟
⎝ 0.
5 ⎠
10
(2.1)
It is desired to have to lowest score possible. The effect of the final score by each
variable was determined by only changing one variable at a time and keeping every other
variable constant, S = 5, H = 5, C = 175, B = 0.9, T = 0.7, M =0.9 From this it was
determined that the best way to have a low score is to miss as few shots as possible.

The robot is expected to have accuracy of at least 70% if it fires all of the possible
balls in the two minute interval the expected score will be:
3.0 Conclusions
3
2
7
−2
(
4)
175
80
( 10)
−
0.
9
( 10)
11
−
0.
7
⎛ 0.
9 ⎞
⎜ ⎟
⎝ 0.
5 ⎠
4
= 1.
005
(1) Premature exclusion of any ideas submitted during brainstorming was detrimental
to the development of the team and teamwork. As the project progressed, the
team learned that regardless of frivolity all ideas submitted were to be given their
due attention in order to cultivate the best design from all team members.
(2) Crude hand sketches were used to communicate initial designs. As the project
approached the decision-making phase, 3D computer models were necessary to
determine the physical dimensions and to perform mass analysis, both critical in
meeting project requirements.
(3) After many calculations, three items were chosen as the most influential in
determination of the estimated final score: (a) total mass, (b) total cost, and (c)
total projectiles blocked. The benefit of mass reduction was worth far more than
the extra strength provided by thicker plates and supports. The thickness of the
chassis was reduced to 1/16 in. and most unneeded material was removed. Total
cost was reduced by relying on in-house fabrication of several components. The
reduction in mass allowed an increase in speed and acceleration, thereby allowing
the defensive robot to block a greater number of projectiles.
(4) The team learned that “Attention to Detail” was the best approach to component
fabrication and mechanical and electrical assembly. Too often the most minute of
details was overlooked and resulted in prolonged and unnecessary
troubleshooting. “Do the job right the first time” eventually became the team
mantra.
(5) Due to limited time and playing field availability, simulations were absolutely
necessary. During the controller design and programming phase especially, a
simulated position generator was used to save time that would translate to money
in the real world.

(6) During initial competitions versus EGR101 students it was seen that EGR345
robots had a significant advantage with respect to speed and reaction time.
However, as the competitions progressed, the autonomous robots bore an
increasingly obvious disadvantage against their human-controlled counterparts.
The human element allowed for learning and adaptation, while the autonomous
robots were “hard-coded” to perform in a limited, eventually predictable manner.
4.0 Recommendations
(1) While mass reduction was a benefit to the overall calculated project score, it
eventually proved to be detrimental in the long run, causing slipping and loss of
responsiveness. Further analysis should be performed in order to determine the
most effective total mass and mass distribution for both robots.
(2) During the course of fabrication, assembly, and testing, electrical components
were found to be extremely sensitive to their thermal and conductive
environment. An investigation should be undergone in order to determine the
optimal placement of the electrical components to prevent exposure to heat, static
electricity, and inadvertent short-circuits.
(3) The storage capacity of the current circuit boards would certainly be challenged
by more proliferative programs (i.e. artificial intelligence). Since these advanced
programming techniques would increase the efficiency and effectiveness of an
autonomous robot, further programming should commence. Additionally,
research should be conducted that may indicate whether a more powerful
microprocessor would benefit this project after such programming is completed.
12

Appendix A: Drawings
13

Appendix B: Electrical Schematics
28

Defensive Robot
29

Offensive Robot
30

Appendix C: Calculations
31

Calculated Ball velocity
Kinematics equations can be written in the x and y directions using the equation
1
s = s0
+ v0
+ at
2
Where s is the final position of the ball, s0 is the initial position of the ball, v0 is the initial
velocity of the ball, a is the acceleration of the ball, and t is the time that the ball travels.
Assuming that the angle is 10°, the resultant equation in the y direction is:
In the x direction, the resultant equation is:
1 ft
0. 333 ft = 0 ft + v0
sin( 10)
+ ( −32.
2 ) t 2
2 s
1 ft
6. 5 ft = 0 ft + v0
cos( 10)
t + ( 0 ) t 2
2 s
Since there are 2 equations with two unknowns, t and v0 can be solved for.
t = 0.
225
v
0 =
29.
4
s
ft
s
Gear Ratio Calculations
To purchase the appropriate motor, calculations were performed to determine the
required voltage and RPM ratings based on the use of a 2 in. diameter wheel/tire:
32
2
2
2

Based on the gearbox and motor manufacturers’ specifications, final drive-shaft angular
velocities were calculated for varying gear ratios as follows:
Rated motor velocity range @ gear ratio = drive-shaft velocity range
5040 RPM – 6300 RPM @ 64.8:1 = 78 RPM – 97 RPM
33

Appendix D: Receipts and Cost Validation
35

BOM
Item #
Item Description
Qty.
Offense
Table 1.1: Project budget and weight inventory.
Qty.
Defense
Total
Qty.
Cost per
Unit
14 Base plate 1 1 2 $2.87
3 Barrel 1 0 1 $3.89
9 Top Hinge 1 0 1 $0.35
10 Bottom Hinge 1 0 1 $0.35
6 Cage 1 1 2 $1.33
18 Rear Pillow Plock 2 2 4 $0.04
7 Fron Pillow Plock 2 2 4 $0.05
16 Wheel 4 4 8 $0.60
16 Tire 4 4 8 $0.30
19 Axles
2 2
15 Spacer 4 4 8 $0.23
2 Barrel cap 1 0 1 $0.34
1 Top Plate 1 1 2 $0.43
12 Coupler 4 4 8 $0.06
11 Bushings 4 4 8 $0.05
16 Nylon Fastener 4 4 8 $0.21
17 FHCS, 6-32 x 1/4 14 12 26 $0.07
8 Gearbox/motor
4 Misc. Electrical Components
5 Mega32 microcontroller
*Supplier abbreviations
McMC McMaster-Carr
GVSU Grand Valley State University
ZR Zagros Robotics
TBB Toy Brick Brigade
RC Radio Shack
1 1
1 1
1 1
4
2
2
2
Total Cost
per Item
36
Supplier*
Supplier
Part #
$5.74 McMC 8199K33
$3.89
$0.35
$0.35
$2.66
$0.16
$0.20
$4.80
$2.40
Material
Mass per Unit
(kg)
Aluminum 0.039
McMC 89965K128 Aluminum 0.141
McMC 8975K64 Aluminum 0.011
McMC 8975K65 0.007
Kutsches Aluminum 0.053
McMC 9536K19 0.005
McMC 9536K19 Aluminum 0.012
TBB 6595 Plastic 0.016
TBB 6594 Rubber 0.010
Tot. Mass Off.
Robot (kg)
Tot. Mass Def.
Robot (kg)
0.039 0.039
0.141 0.000
0.011 0.000
0.007 0.000
0.053 0.053
0.010 0.010
0.024 0.024
0.064 0.064
0.040 0.040
$0.34 $1.36 FAB 88625K63 Steel 0.014 0.028 0.028
$1.84 Lowes
$0.34
Nylon 0.001
McMC 86985K56 Aluminum 0.014
$0.86 McMC 8199K33
$0.48
$0.40
$1.68
$1.81
Aluminum 0.005
Kutsches Aluminum 0.003
McMC 8538K16 Nylon 0.001
Lowes 0.001
McMC 92210A196 Steel 0.001
0.004 0.004
0.014 0.000
0.005 0.005
0.012 0.012
0.004 0.004
0.004 0.004
0.014 0.012
$9.95 $19.90 ZR 72003 N/A 0.055 0.055 0.055
$6.23 $12.46 RC 0.029 0.029 0.029
$30.00 $60.00 GVSU N/A 0.035 0.035 0.035
Total Cost $121.68 Total Mass per Robot 0.593 0.418

--------------------------------------
Order Date: 10/4/2006 6:33:57 PM
Payment By: Paypal.com
Buyer Requests Insurance: No
--------------------------------------
Comments from Buyer:
--------------------------------------
Order Batch Summary:
--------------------------------------
Total Items: 16
Unique Items (lots): 2
Total: $7.20
--------------------------------------
Items in Order:
--------------------------------------
[Used] Black Tire 49.6 x 28 VR (x8) ..... $0.30 each = $2.40
[Used] Dark Gray Wheel 49.6 x 28 VR with Axle Hole (x8) ..... $0.60
each =
$4.80
--------------------------------------
Buyer Information:
--------------------------------------
BrickLink Username: cody_116 (0)
E-Mail: kodice_116@hotmail.com
IP Address: 148.61.176.128
Address:
cody Holstege
10599 taylor street
Zeeland, MI 49464
USA
--------------------------------------
Seller Information:
--------------------------------------
BrickLink Username: ToyBrickBrigade (8032)
E-Mail: bricklink@toybrickbrigade.com
BrickLink Store Name: Toy Brick Brigade
http://www.BrickLink.com/store.asp?p=ToyBrickBrigade
41

Top and bottom Hinge Plates:
Alloy 6061 Aluminum Square Bar 1/2" Square, 6' Length
In stock at $16.41 Each
Cost: $0.035 / foot
Barrel:
McMaster Prices
9008K23
89965K128
(Same as 89965K781)
Aluminum Tubing 1-3/4" Od, , 1.62" Id, .065" Wall Thickness, 3'L
In stock at $20.02 Each
Cost: $0.56 / foot
Base and Top Plates
8199K33
Alloy 5052 Aluminum Sheet W/#4 Satin Finish .062" Thick, 12" X 24"
In stock at $20.63 Each
Cost: $0.072 / square inch
Pillow Blocks
Colored Aluminum Shim Stock .025" Thick, 6" X 24", White
In stock at $6.94 Each
Cost: $0.048 / square inch
Axles
9536K19
88625K63
O1 Tool Steel Tight-Tolerance Rod 4 Millimeter Diameter, 3' Length
In stock at $2.22 Each
Cost: $0.062 / inch
Barrel Cap
42

Alloy 2024 Aluminum Rod 7/8" Diameter, 1' Length
In stock at $9.12 Each
Cost $0.913 / in
Bushings
White Nylon 6/6 Rod 3/8" Diameter
In stock at $0.55 per Ft.
This product is sold in Lengths of 5 Ft.
Cost: $0.05 / foot
Fasteners:
86985K411
(Same as 86985K56)
8538K16
92949A144
18-8 Ss Button Head Socket Cap Screw 6-32 Thread, 1/4" Length
In stock at $5.29 per Pack
This product is sold in Packs of 100
Cost: $0.053 / fastener
43

Appendix E: C Programs
44

Defensive Robot Controller Program
// Include header files, .c file
#include
#include
#include
#include
#include "sio.c"
//======================================================================================
// Global Definitions
#define c_kinetic_pos 0xC0 // Define kinetic friction coefficient for + direction
#define c_kinetic_neg 0xC0 // Define kinetic friction coefficient for - direction
#define c_static_pos 0xC0 // Define static friction coefficient for + direction
#define c_static_neg 0xC0 // Define static friction coefficient for - direction
#define c_max 255 // Define maximum position
#define c_min 255 // Define magnitude of minimum position
#define CLK_ms 10 // Set the updates for every 10ms
#define T 10 // Define as 10 ms, must divide by 1000 later
#define Kp 10 // Define to 1,3,1
#define Ki 0 // Define to 1,1,3
#define Kd 0
#define US_DEF 1
#define THEM_OFF 3
#define THRESHOLD 15
#define mult 3.0
int moving = 0; // Set variable to show it starts without moving
int e_sum = 0; // Used in integrate function
int prev_err = 0; // used in derivitive function
unsigned int CNT_timer1; // Time variable
volatile unsigned int CLK_ticks = 0; // Current number of ms
volatile unsigned int CLK_seconds = 0; // Current number of seconds
int rpos[5];
int pos_last = 0;
//======================================================================================
// Function definitions
//
//......................................................................................
int integrate(int e)
{
e_sum += e*T;
}
if(e_sum > 10000) e_sum = 10000; // Set an upper limit
if(e_sum < -10000) e_sum = -10000; // Set a lower limit
return e_sum;
//......................................................................................
int derivitive(int e)
{
int diff;
diff = (e - prev_err)/10;
45

eturn diff;
}
//......................................................................................
int controller(int Cd, int Cf)
{
int Ce; // Error variable
int Cw; // Corrected count
}
Ce = Cd - Cf;
Cw = (Kp * Ce) + (Ki * integrate(Ce) / 1000) + (Kd * derivitive(Ce));
if(US_DEF == 1) {
if((rpos[THEM_OFF] < THRESHOLD) && (rpos[US_DEF] < THRESHOLD)) Cw = 0;
else Cw *= -1;
}
return Cw;
//......................................................................................
void AD_setup()
{
ADCSRA = 0x80;// turn on ADC
DDRA = (unsigned char)0; // set port A to input
}
//......................................................................................
void AD_read(void) { // interrupt driven encoder update
int count;
for (count = 0; count < 4; count++) {
ADMUX = (0x40 + count); // REFS1=0,REFS0=1,ADLAR=0,MUX4=0 |
MUX3=0,MUX2=0,MUX1=0,MUX0=1
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
rpos[count + 1] = ADCW >> 2;
}
}
if(pos_last != rpos[US_DEF])
{
moving = 1;
}
else
{
moving = 0;
}
//......................................................................................
int deadband(int c_wanted)
{// Call this routine when updating
int c_pos;
int c_neg;
int c_adjusted;
if(moving == 1) // If moving -> kinetic
{
c_pos = c_kinetic_pos;
c_neg = c_kinetic_neg;
}
else // Not moving -> static
{
c_pos = c_static_pos;
c_neg = c_static_neg;
}
46

}
if(c_wanted == 0)
{ // Turn off the output
c_adjusted = 0;
}
else if(c_wanted > 0)
{ // Positive motion
c_adjusted = c_pos + (unsigned)(c_max - c_pos) * c_wanted / c_max;
if(c_adjusted > c_max)
c_adjusted = c_max;
}
else { //Negative motion
c_adjusted = -c_neg - (unsigned)(c_min - c_neg) * -c_wanted / c_min;
if(c_adjusted < -c_min) c_adjusted = -c_min;
}
return c_adjusted;
//......................................................................................
void PWM_init()
{ // Initialize the PWM outputs, configure
}
DDRD |= (1 = 0)
{ // Set the direction bits to CW on, CCW off
PORTC = (PINC & 0xFC) | 0x02; /* bit 1 on, 0 off */
if(v_adjusted > 255){ // Clip output over maximum
RefSignal = 255;
} else{
RefSignal = v_adjusted;
}
} else{ // Reverse output sign
// Set the direction bits to CW off, CCW on
47

}
}
PORTC = (PINC & 0xFC) | 0x01; // bit 0 on, 1 off
if(v_adjusted < -255){ // Clip output below minimum
RefSignal = 255;
} else{
RefSignal = -v_adjusted; /* flip sign */
}
return RefSignal;
//......................................................................................
void IO_update()
{ // This routine will run once per interrupt to update PWM
}
AD_read();
PWM_update(v_output(deadband(controller(rpos[US_DEF],rpos[THEM_OFF]))));
//......................................................................................
SIGNAL(SIG_OVERFLOW0){
}
CLK_ticks += CLK_ms;
if(CLK_ticks >= 1000)
{ // The number of interrupts between output changes
CLK_ticks = CLK_ticks - 1000;
CLK_seconds++;
}
IO_update();
TCNT0 = CNT_timer1;
sei();
//......................................................................................
void CLK_setup()
{ // Start the interrupt service routine
TCCR0 = (0

{
}
PWM_init();
sio_init();
AD_setup();
CLK_setup();
DDRB = 0x00;
//======================================================================================
// Main Program Loop
int main(){
}
while((PINB & 0x01) != 1);
IO_setup();
while((PINB & 0x01) == 1)
{
}
outln("outloop");
OCR1A = 0x00;
sio_cleanup();
return 1;
49

Offensive Robot Controller Program
// AUTHOR: TEAM 6
// COURSE: EGR345 PROJECT
// DATE: 11-12-06
// FILENAME: OFFENSE_V1.C
// DESCRIPTION: THIS PROGRAM IMPLEMENTS A MOSTLY-AUTONOMOUS MOTION CONTROLLER FOR
// THE DEFENSIVE ROBOT.
#include
#include
#include
#include
#define C_MAX 255 // Maximum PWM output
#define C_MIN 255 // Minimum PWM output
#define CLK_ms 10 // update every 10 ms
#define US_OFF 1
#define THEM_OFF 3
#define THEM_DEF 4
#define OPEN 1
#define CLOSED 0
#define BALL 1
#define NO_BALL 0
#define PLAY_GAME 1
#define END_GAME 0
int accel = 16,
direction = 0,
moving = 0, // Motor starts from rest
pwm_out = 0, // PWM output
SNEG = 0x80, // PWM output that overcomes static friction, negative direction
SPOS = 0x80, // PWM output that overcomes static friction, positive direction
KNEG = 0x80, // Lowest PWM output that keeps motor moving, negative direction
KPOS = 0x80, // Lowest PWM output that keeps motor moving, positive direction
rpos[5],
START = 0,
Goal[] = {0, 0, 0, 0},
gmin[] = {0, 21, 106, 191},
gmax[] = {0, 63, 149, 234};
unsigned int CNT_timer0; // The delay time
// FUNCTION PROTOTYPES
void AD_setup(void);
int db(int c_target);
void PWM_init();
void PWM_update(int value);
int v_out(int v_adj);
void IO_setup();
void IO_update();
void CLK_setup(void);
int Reload(void);
int AttackGoal(int goal);
void FireCannon(void);
void Delay(int ticks);
// FUNCTION DECLARATIONS
void Delay(int ticks)
{
// ticks are approximately 1ms
volatile int i, j;
for(i = 0; i < ticks; i++)
{
for(j = 0; j < 1000; j++){}
}
}
50

************************************************************************************
void FireCannon(void) {
PORTC |= PC5; // Activate air supply to launch ball...
Delay(500); // ...wait 0.500 sec for ball to leave barrel...
PORTC &= PC5; // ...deactivate air supply.
}
//************************************************************************************
int AttackGoal(int goal) {
// If our offense is closer to prox than min location of goal...
if (rpos[US_OFF] < gmin[goal]) {
// ...accelerate toward min location of goal...
while (rpos[US_OFF] < gmin[goal]) {
if ((pwm_out += accel) > 255) pwm_out = 255;
}
// ...and fire on the move.
FireCannon();
return NO_BALL;
}
// If our offense is further from the prox than max location of goal...
else if (rpos[US_OFF] > gmax[goal]) {
// ...accelerate toward max location of goal...
while (rpos[US_OFF] > gmax[goal]) {
if ((pwm_out -= accel) > -255) pwm_out = -255;
}
// ...and fire on the move.
FireCannon();
return NO_BALL;
}
// Our offense must already be located at the open goal, fire where we stand.
else FireCannon();
return NO_BALL;
}
//************************************************************************************
int Reload(void) {
// Wherever we are, stop.
pwm_out = 0;
IO_update();
}
// While our offense is not at home position...
while (US_OFF > 0) {
// ...accelerate toward home.
if ((pwm_out -= accel) < -255) pwm_out = -255;
IO_update();
}
// Offense has reached home postion.
// Wait 2 seconds for manual reload.
Delay(2000);
return BALL;
//************************************************************************************
void AD_setup(void) {
DDRA = 0x00; // Set Port A to inputs
}
//************************************************************************************
int db(int c_target) {
int c_pos,
c_neg,
c_adj;
if (moving) {
c_pos = KPOS;
51

}
}
else {
c_neg = KNEG;
c_pos = SPOS;
c_neg = SNEG;
}
if (c_target == 0) { // Turn off output
c_adj = 0;
}
else if (c_target > 0) { // Positive output
c_adj = c_pos + (unsigned)(C_MAX - c_pos) * c_target / C_MAX;
if (c_adj > C_MAX) c_adj = C_MAX;
}
else { // Negative output
c_adj = -c_neg - (unsigned)(C_MIN - c_neg) * -c_target / C_MIN;
if (c_adj < -C_MIN) c_adj = -C_MIN;
}
return c_adj;
//************************************************************************************
void PWM_init() { // Initialize PWM output
DDRD |= (1 255) {
RefSig = 255;
}
else {
RefSig = v_adj;
}
}
else { // Set CW off, CCW on
PORTC = (PINC & 0xFC) | 0x01; // Bit 1 off, 0 on
if (v_adj < -255) {
RefSig = 255;
}
else {
RefSig = -v_adj;
}
}
return RefSig;
}
//************************************************************************************
void IO_setup() {
CLK_setup();
PWM_init();
AD_setup();
DDRB = 0x00; // Set PB3 to digital input for "Start Game"
}
52

************************************************************************************
void IO_update() {
PWM_update(v_out(db(pwm_out)));
}
//************************************************************************************
SIGNAL(SIG_OVERFLOW0) {
IO_update();
TCNT0 = CNT_timer0;
// Change to and read ADC channel 0 for our offense position
ADMUX = 0x40; // REFS1=0,REFS0=1,ADLAR=0,MUX4=0 | MUX3=0,MUX2=0,MUX1=0,MUX0=1
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
rpos[1] = ADCW >> 2;
// Change to and read ADC channel 2 for enemy defense position
ADMUX = 0x42; // REFS1=0,REFS0=1,ADLAR=0,MUX4=0 | MUX3=0,MUX2=0,MUX1=0,MUX0=1
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
rpos[3] = ADCW >> 2;
// Change to and read ADC channel 3 for enemy offense position
ADMUX = 0x43; // REFS1=0,REFS0=1,ADLAR=0,MUX4=0 | MUX3=0,MUX2=0,MUX1=1,MUX0=0
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
ADCSRA = 0xC0;
while ((ADCSRA & _BV(ADSC)) != 0);
rpos[4] = ADCW >> 2;
}
// Check PB3 for START signal
if((PORTB & PB3)==(PB3)) START = 1;
else START = 0;
//************************************************************************************
void CLK_setup(void) { // Start the interrupt service routine
TCCR0 = (0

There is always at least one goal open.
// Determine which goal is currently open.
for (count = 1; count
gmax[count])) &&
((rpos[THEM_OFF] < gmin[count]) || (rpos[THEM_OFF] >
gmin[count])))
Goal[count] = OPEN;
else Goal[count] = CLOSED;
}
}
// Attempt an attack on an open goal.
for (count = 1; count