Friday, December 21, 2012

a brief introduction of Sack Attack




Field view

field
preloads(red)
preloads(blue)
total
sack
86
6
6
98
bonus sack
4
0
0
4
(0.5 lbs for each sack)


Scoring

floor goal
trough
high goal
sack
1
5
10
bonus sack
6
10
15

1.       10 points for the Alliance with the most Robots Parked at the end of the match. (no points are awarded if each Alliance has the same amount of Robot Parked)
2.       10 points for the Alliance with the most score at the end of Autonomous Period

Thursday, December 20, 2012

End Of Robo Boot Camp :: 12_20_2012


The last day of Robo Boot Camp. We rebuilt both drive trains to make more rigid.


"Sword" (Small Form Factor 15x15x15) (Pictured Above)
*H-Drive 
*4 x Motor 393 (Speed) for Corner Wheels 
*2 x Motor 296 for Strafe Wheels 
*2 x Integrated Encoder for rear wheels




















"Shield" (Large Form Factor 24x24x24) (Pictured Above)
*Mecanum Drive
*4 x Motor 393 (Torque) for Corner Wheels
*4 x Motor 393 (Torque) for 2-bar chain lift (In Progress) Gear Ratio 1::4.83


















Back: "Shield"  (Pictured Above) 
Front: "Sword"
Right of Shield: Sword's Feeding Mechanism and Platform
Right of Sword: Shield's Feeding Mechanism

Line-Following Code :: 12_20_2012

*Attempted to write line following code with two sensors. 3 Sensors was more reliable.
*Reduced lines of code in the main task and cleaned up functions
*Brainstormed fault detection: What will robot do if no lines are sensed?
*Reduce amount of hard-coding. Push calibration values to top of code
*Added int (debugstate) to allow monitoring of which section of code caused failure in routine
*To do: Write header and program explanation.
*Future: Continue routine. Move to second target




#pragma config(I2C_Usage, I2C1, i2cSensors)
#pragma config(Sensor, in1,    midfollower,    sensorLineFollower)
#pragma config(Sensor, in3,    pressureSens,   sensorAnalog)
#pragma config(Sensor, in8,    leftfollower,   sensorLineFollower)
#pragma config(Sensor, in4,    rightfollower,  sensorLineFollower)
#pragma config(Sensor, I2C_1,  leftDrive,      sensorQuadEncoderOnI2CPort,    , AutoAssign)
#pragma config(Sensor, I2C_2,  rightDrive,     sensorQuadEncoderOnI2CPort,    , AutoAssign)
#pragma config(Sensor, I2C_3,  ,               sensorQuadEncoderOnI2CPort,    , AutoAssign)
#pragma config(Motor,  port1,           bumperStrafe,  tmotorVex269, openLoop, reversed)
#pragma config(Motor,  port2,           leftDrive,     tmotorVex393HighSpeed, openLoop, reversed, encoder, encoderPort, I2C_2, 1000)
#pragma config(Motor,  port3,           leftBottomLift, tmotorVex393, openLoop)
#pragma config(Motor,  port4,           leftTopLift,   tmotorVex393, openLoop, encoder, encoderPort, I2C_3, 1000)
#pragma config(Motor,  port5,           leftFeed,      tmotorVex393, openLoop)
#pragma config(Motor,  port6,           rightFeed,     tmotorVex393, openLoop)
#pragma config(Motor,  port7,           rightTopLift,  tmotorVex393, openLoop)
#pragma config(Motor,  port8,           rightBottomLift, tmotorVex393, openLoop)
#pragma config(Motor,  port9,           rightDrive,    tmotorVex393HighSpeed, openLoop, encoder, encoderPort, I2C_1, 1000)
#pragma config(Motor,  port10,          bootStrafe,    tmotorVex269, openLoop, reversed)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//


const int linelength = 850;
int midthreshold = 1500;
int leftthreshold = 1500;
int rightthreshold = 1500;
void linefollower();
void turnleft();
void turnright();
void goforward();
void gobackward();
bool linedetector();
int debugstate = 0;
int linecrossdetected = 0;
int lastturn = 0;  //Left = 1 Right = 2 Forward = 3

void goforward()
{
motor[leftDrive] = 50;
motor[rightDrive] = 50;
}
void gobackward()
{
motor[leftDrive] = -30;
motor[rightDrive] = -30;
}
void turnleft()
{
motor[leftDrive] = 0;
motor[rightDrive] = 30;
}
void turnright()
{
motor[leftDrive] = 30;
motor[rightDrive] = 0;
}
void strafeleft()
{
motor[bootStrafe]=55;
   motor[bumperStrafe]=-55;
}
void straferight()
{
motor[bootStrafe]=-55;
   motor[bumperStrafe]=55;
}
void stopmotors()
{
motor[leftDrive] = 0;
motor[rightDrive] = 0;
motor[bootStrafe]=0;
  motor[bumperStrafe]=0;
}
void initialsearch()
{
//move to the left until lines are detected
//insert code here for deployment.
while(linedetector()==false)
  {
     strafeleft();
     goforward();
     debugstate = 1;
  }

  //turn  off strafe motor
  stopmotors();
  debugstate = 2;
  wait10Msec(20);
}
void findlinecrossing()
{
while (linecrossdetected == 0)
  {
  linefollower();
  }
  linecrossdetected = 0;
  debugstate = 100;
  stopmotors();
}
void followlinedistance(int length)
{
 nMotorEncoder[rightDrive] = 0;
  nMotorEncoder[leftDrive] = 0;

  while(nMotorEncoder[leftDrive]<length)
  {
      linefollower();
  }
}
// turn 180 degrees
void turnhalfcircle()
{
int initialleft = nMotorEncoder[leftDrive];
int initialright = nMotorEncoder[rightDrive];
while(nMotorEncoder[leftDrive]-initialleft<430&&nMotorEncoder[rightDrive]-initialright>-497)
{
motor[rightDrive] = -50;
  motor[leftDrive] = 50;
}
debugstate = 180;
}

//rotate 90 degrees left
//not working
void rotateleft()
{
int initialleft = nMotorEncoder[leftDrive];
int initialright = nMotorEncoder[rightDrive];

while(nMotorEncoder[leftDrive]-initialleft<215&&nMotorEncoder[rightDrive]-initialright<250)
{
motor[rightDrive] = 50;
  motor[leftDrive] = -50;
}
}

task main()
{
//robot correctly strafes left, finds line, moves forward, finds cross section and moves forward to target
initialsearch();
  findlinecrossing();
  followlinedistance(linelength);
  stopmotors();
  wait10Msec(200);
 // turnhalfcircle();
 // findlinecrossing();//not functioning
 // debugstate = 60;
 // rotateleft();
 // while(linedetector()==false)
 // {
// straferight();
 // }
 //followlinedistance(400);

}
void linefollower()
{  //Check to see if both left and right are on black if so, we are over the line
if(SensorValue[midfollower] < midthreshold)
    {
    //go forward
  debugstate = 10;
  lastturn = 3;
    goforward();
    }
    //check the left sensor if both aren't high
    else if(SensorValue[leftfollower]<leftthreshold)
    {
    lastturn = 1;
    debugstate = 20;
      turnright();
     }
     //if both aren't high and the left isn't low then it must be right
     else if(SensorValue[rightfollower]<rightthreshold)
    {
    lastturn = 2;
    debugstate=30;
    turnleft();
      }
      else
      {
      debugstate=50;
      if (lastturn == 1)  //last turn was left so turn right
      {
      debugstate=51;
      turnright();
      }
      if (lastturn == 2)
      {
      debugstate=52;
      turnleft();
      }
      if (lastturn == 3)
      {
      debugstate=53;
      gobackward();
      }
      }
      //both left and right trigger at the same time at crossing.
     if(SensorValue[leftfollower]<leftthreshold&&SensorValue[rightfollower]<rightthreshold)
     {
      debugstate = 40;
        linecrossdetected = 1;
     }
}
bool linedetector()
{
    if(SensorValue[leftfollower]<leftthreshold||SensorValue[rightfollower]<rightthreshold||SensorValue[midfollower]<midthreshold)
    {
      return true;
    }
    else
      return false;
}



Wednesday, December 19, 2012

End of Robo Camp Day 3

*Tested compound lift system: 1::3.33 connected to 1::3.33. Lift was powerful as expected but deemed to slow for competition. We re-designed to single gearing 1::4.83. 
*In Progress: Replicating "Sword" feeder system on a larger scale
*Because of the new lift system not being able to go rotate into a vertical position, we opted for a chain-bar lift similar to "Swords" initial design. 

"Sword" 

*No progress on this robot today. Still waiting on parts to complete 8-bar lift. 
*Feeder system becoming loose with continued testing. Will change from  keps nuts to nylock.

Programming
*Continued work on the line feeding system. Key goals is to increase speed while maintaining reliability of the previous code
*Conducted inventory of available sensors. We only found 1 working to use for "Shield". Will have to order more. We plan on using 3 on each robot.
*In Progress: Writing code for an arc turn
*In Progress: Writing code to use integrated encoders in conjunction with line sensors.

Day 4 Tomorrow :D



Tuesday, December 18, 2012

Here is Elmer's Line Sensor, Works heavenly:


#pragma config(I2C_Usage, I2C1, i2cSensors)
#pragma config(Sensor, in1,    midfollower,    sensorLineFollower)
#pragma config(Sensor, in4,    leftfollower,   sensorLineFollower)
#pragma config(Sensor, in8,    rightfollower,  sensorLineFollower)
#pragma config(Sensor, I2C_1,  leftLift,       sensorQuadEncoderOnI2CPort,    , AutoAssign)
#pragma config(Sensor, I2C_2,  rightLift,      sensorQuadEncoderOnI2CPort,    , AutoAssign)
#pragma config(Motor,  port1,           bumperStrafe,  tmotorVex269, openLoop, reversed)
#pragma config(Motor,  port2,           leftDrive,     tmotorServoContinuousRotation, openLoop, reversed)
#pragma config(Motor,  port3,           leftBottomLift, tmotorVex393HighSpeed, openLoop, encoder, encoderPort, I2C_1, 1000)
#pragma config(Motor,  port4,           leftTopLift,   tmotorVex393HighSpeed, openLoop)
#pragma config(Motor,  port5,           leftFeed,      tmotorVex393HighSpeed, openLoop)
#pragma config(Motor,  port6,           rightFeed,     tmotorVex393HighSpeed, openLoop, reversed)
#pragma config(Motor,  port7,           rightTopLift,  tmotorVex393HighSpeed, openLoop, reversed)
#pragma config(Motor,  port8,           rightBottomLift, tmotorVex393HighSpeed, openLoop, reversed, encoder, encoderPort, I2C_2, 1000)
#pragma config(Motor,  port9,           rightDrive,    tmotorServoContinuousRotation, openLoop)
#pragma config(Motor,  port10,          bootStrafe,    tmotorVex269, openLoop, reversed)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//

int midthreshold = 1800;
int leftthreshold= 1800;
int rightthreshold= 1800;
int startleft;
int startright;
void linefollower();
bool verticaldetector();
bool horizontaldetector();
task main()
{
  //move to the left until lines are detected
while(verticaldetector()==false)
  {
      motor[bootStrafe]=60;
      motor[bumperStrafe]=-60;
      motor[leftDrive]=60;
      motor[rightDrive]=60;

  }
  motor[bootStrafe]=0;
  motor[bumperStrafe]=0;
  wait1Msec(200);
  motor[bootStrafe]=-50;
  motor[bumperStrafe]=50;
  wait1Msec(200);
  motor[bootStrafe]=0;
  motor[bumperStrafe]=0;
  wait1Msec(200);
  startleft = SensorValue[leftLift];
  startright = SensorValue[rightLift];

  //forward collection and archturn
 while(SensorValue[leftLift]-startleft<880&&SensorValue[rightLift]-startright<880)
 {
      linefollower();
 }
 motor[leftDrive]=0;
 motor[rightDrive]=0;
 wait1Msec(200);
 //collection here
 //arch turn right
 motor[leftDrive]=30;
 motor[rightDrive]=-30;
 motor[bumperStrafe]=60;
 motor[bootStrafe]=-60;
 wait1Msec(800);
 while(verticaldetector()==false)
 {
    motor[leftDrive]=30;
    motor[rightDrive]=-30;
    motor[bumperStrafe]=80;
    motor[bootStrafe]=-80;
 }
 motor[leftDrive]=0;
 motor[rightDrive]=0;
 motor[leftDrive]=-30;
    motor[rightDrive]=30;
    motor[bumperStrafe]=-60;
    motor[bootStrafe]=60;
 wait1Msec(100);

  motor[leftDrive]=0;
    motor[rightDrive]=0;
    motor[bumperStrafe]=0;
    motor[bootStrafe]=0;
 wait1Msec(200);


}
void linefollower()
{
if(SensorValue[midfollower] < midthreshold)
    {
      motor[leftDrive]=100;
      motor[rightDrive]=100;
    }

    if(SensorValue[leftfollower]<leftthreshold)
    {
        motor[leftDrive]=30;
            motor[rightDrive] = 100;
     }
     if(SensorValue[rightfollower]<rightthreshold)
    {
    motor[leftDrive]= 100;
      motor[rightDrive] =30;
      }
     if(SensorValue[midfollower]<midthreshold&&SensorValue[leftfollower]<leftthreshold&&SensorValue[rightfollower]<rightthreshold)
     {

          motor[leftDrive]= 30;
       motor[rightDrive] =-30;

     }

}
bool verticaldetector()
{
    if(SensorValue[midfollower]<midthreshold&&SensorValue[leftfollower]>leftthreshold&&SensorValue[rightfollower]>rightthreshold)
    {
      return true;
    }
    else
      return false;
}
bool horizontaldetector()
{
    if(SensorValue[midfollower]<midthreshold&&SensorValue[leftfollower]<leftthreshold&&SensorValue[rightfollower]<rightthreshold)
    {
      return true;
    }
    else
      return false;
}


Here is the Pesudo-Code/Template for what we want Sword to do. Implementation of the code is mainly Elmer's code, so I won't bother showing the C++ version of this:
/*******************************************
                 PSUEDOCODE
*******************************************/
/*
psuedocode:
From starting position:

deployLift
{
raise lift, 0.5 sec
drive forward,
set lift, lowered
}

findFirstLine
{
  Get on the white line
}

followLineToSacks
{
  lineFollower - drive forwawrd uses findLine (detect)
  sackDetector - detects sac
}

collectionSequence
{
  collectFrontSacks
  {
set collection, to collect 5 sec
reverse, strafe left, and forward until wall or collect all sacs
strafe right
  }

Lift/Dump
{
set lift to raise
set collection to dump sacs for 5 secs
set lift to lowered
  }
}
findSecondLine
{
turn 90 clockwise
back-up untill hit wall - Decelleration and pressure sensor
straft right until detect line
}
followLineToSack // again using lineFollower and sackDetector
{
  go forward until detect sac
}
collectSequence
{
  set collection,to collect 5 sec
}

//Debatable method to dump #1
turn90Arch
{
  reverse, strafe, findLine, dump
}

//Debatable method to dump #2
{
back-up until hit the wall - Decelleration and Pressure Sensor
go forward until detect a horizontal line
turn 90 counter-clockwise until detect line
go forward for an x amount of times
Lift/Dump
{
set lift to raise, set colletion to dump sacs for 5 secs
set lift to lowered
}
}

strafe right
straft right for x amount, set collection to collect 5 secs

Lift/Dump
{
set lift to raise, set colletion to dump sacs for 5 secs
set lift to lowered
 }

collectionSequence
{
strafe right, drive forward until detects sac
set collectioin to collect 5 sec
forward and reverse
}

strafe left, until our trough

Lift/Dump
{
set lift to raise
set collection to dump sacs for 5 secs
set lift to lowered
turn 90 counter clockwise
}*/


Monday, December 17, 2012

Electrical :: Experiment - Peak Draw on HS Motor

Task: Measure draw (amps) through a motor without load (free current), when instantly stopped (peak current), and stall current (when shaft held).

Purpose: Determine why circuit breaker trips when lifting arm and hitting underneath trough. Robot is uncontrollable for 6-10 seconds.

Procedure:
*Create circuit with 2-wire motor using cortex as power supply
*Measure amps with meter when spinning under no load (Free Current)
*Stop motor shaft attached to sprocket with hand, measure (Peak Current)
*Wait for reading to stabilize, measure (Stall Current)




















Data:

Motor 393
Measurement :: Trial 1 :: Trial 2 :: Trial 3 :: Trial 4
Free Current :: 0.25A :: 0.25A :: 0.25A :: 0.24A
Peak Current :: 5.61A :: 5.67A :: 5.49A :: 5.59A
Stall Current :: 0.29A :: 0.27A :: 0.28A :: 0.28A

Motor 269
Measurement :: Trial 1 :: Trial 2 :: Trial 3 :: Trial 4
Free Current :: 0.26A :: 0.27A :: 0.25A :: 0.26A
Peak Current :: 4.28A :: 4.02A :: 3.71A :: 4.60A
Stall Current :: 0.56A :: 0.57A :: 0.56A :: 0.57A

Conclusions
**Under Construction**

Future Work
Test 393 Speed Mode
Incorporate data into smart motor programming to prevent tripping circuit breaker



Modeling software/freeware :: Golems


I used a modeling/simulation free-ware program named Golems to illustrate my initial design concept. I built a replica of the game field to scale. This design is for Robot A, the 15”x15”x15” robot. The idea is basically a plow/rake combination and could possibly descore efficiently. The rake/plow mechanism would be raised by an actuating arm to the 15” trough goal. 


VEX Outreach :: Collegewood Elementary :: 08_20_2012



We were invited to do a VEX Robotics Demo at Collegewood Elementary. Over a course of 3 weeks, students would build a squarebot, modify it, and compete against their peers in the ping-pong soccer challenge!


Clutch Prototype

Task: Ability to use a set of motors to control multiple functions (i.e. collect, lift, descore)

Programming :: "Shield" Mecanum Drive with motor limit and threshold


#pragma config(Motor,  port4,           frontLeft,     tmotorVex393, openLoop, reversed)
#pragma config(Motor,  port5,           frontRight,    tmotorVex393, openLoop)
#pragma config(Motor,  port6,           backLeft,      tmotorVex393, openLoop, reversed)
#pragma config(Motor,  port7,           backRight,     tmotorVex393, openLoop)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//

/***************************************************************************

Program for Mecanum Drive
- Left joystick, Y-axis will control robot's forward and backward movement
- Left joystick, X-axis will control robot's left and right strafe movement
- Right joystick, X-axis will control robot's clockwise and counterclockwise rotation

Mount San Antonio College VEX Team

***************************************************************************/

/***************Main Task***************/


task main(){


while (1 == 1)

{
int Y1 = 0, X1 = 0, X2 = 0, threshold=20, motorMax = 100;
if(abs(vexRT[Ch3]) > threshold)Y1 = vexRT[Ch3];
else Y1 = 0;
if(abs(vexRT[Ch4]) > threshold)X1 = vexRT[Ch4];
else X1 = 0;
if(abs(vexRT[Ch1]) > threshold)X2 = vexRT[Ch1];
else X2 = 0;
/*Remote Control Commands */
//Front Right Check
if ((Y1 - X2 + X1) > 100){
motor[frontRight] = motorMax;
}else{
motor[frontRight] = Y1 - X2 - X1;
}
//Back Right Check
if ((Y1 - X2 - X1) > 100){
motor[backRight] = motorMax;
}else{
motor[backRight] = Y1 - X2 + X1;
}
//Front Left Check
if ((Y1 + X2 + X1) > 100){
motor[frontLeft] = motorMax;
}else{
motor[frontLeft] = Y1 + X2 + X1;
}
//Back Left Check
if ((Y1 + X2 - X1) > 100){
motor[backLeft] = motorMax;
}else{
motor[backLeft] = Y1 + X2 - X1;
}
}
}

Programming :: "Sword" Driver Control


#pragma config(UART_Usage, UART2, uartNotUsed, baudRate4800, IOPins, None, None)
#pragma config(I2C_Usage, I2C1, i2cSensors)
#pragma config(Sensor, I2C_1,  leftLift,       sensorNone)
#pragma config(Sensor, I2C_2,  rightLift,      sensorNone)
#pragma config(Motor,  port1,           leftStrafe,    tmotorVex269, openLoop)
#pragma config(Motor,  port2,           leftDrive,     tmotorServoContinuousRotation, openLoop, reversed)
#pragma config(Motor,  port3,           leftBottomLift, tmotorVex393, openLoop)
#pragma config(Motor,  port4,           leftTopLift,   tmotorVex393, openLoop)
#pragma config(Motor,  port5,           leftFeed,      tmotorVex393HighSpeed, openLoop)
#pragma config(Motor,  port6,           rightFeed,     tmotorVex393HighSpeed, openLoop, reversed)
#pragma config(Motor,  port7,           rightTopLift,  tmotorVex393, openLoop)
#pragma config(Motor,  port8,           rightBottomLift, tmotorVex393, openLoop)
#pragma config(Motor,  port9,           rightDrive,    tmotorServoContinuousRotation, openLoop)
#pragma config(Motor,  port10,          rightStrafe,   tmotorVex269, openLoop, reversed)
//*!!Code automatically generated by 'ROBOTC' configuration wizard               !!*//

/****************************************************************
        Mount San Antonio College VEX Team
****************************************************************/
/****************************************************************
Program for Robot A (15" x 15" x 15") - "Sword"

Remote Control Configuration:
- Left joystick, Y-axis will control robot's forward and backward movement
- Left joystick, X-axis will control robot's side-to-side strafe movement
- Right joystick, X-axis will control robot's clockwise and counterclockwise rotation
- Button 6 (U/D) will control feed
- Button 5 (U/D) will control arm

/****************************************************************
        Mount San Antonio College VEX Team
****************************************************************/


task main()
{
while (1 == 1)
{

//Initialize Values

int Y1 = 0, X2 = 0, X1 = 0, threshold=25;

//Arm Function

if(vexRT[Btn5U] == 1) //Lift arm
      {
    motor[leftTopLift] = 115;
    motor[leftBottomLift] = 115;
    motor[rightTopLift] = 115;
    motor[rightBottomLift] = 115;
      }
  else if(vexRT[Btn5D] == 1) //Lower arm
      {
    motor[leftTopLift] = -80;
    motor[leftBottomLift] = -80;
    motor[rightTopLift] = -80;
    motor[rightBottomLift] = -80;
      }
  else //Stop motors if no button
      {
    motor[leftTopLift] = 0;
    motor[leftBottomLift] = 0;
    motor[rightTopLift] = 0;
    motor[rightBottomLift] = 0;
      }
//Feed Fucntion

if(vexRT[Btn6U] == 1) //Intake
    {
    motor[leftFeed] = 127;
    motor[rightFeed] = 127;
    }
  else if(vexRT[Btn6D] == 1) //Score
    {
    motor[leftFeed] = -127;
    motor[rightFeed] = -127;
    }
  else //Stop motor if no button
    {
    motor[leftFeed] = 0;
    motor[rightFeed] = 0;
    }

//Drive Function

  if(abs(vexRT[Ch3]) > threshold)Y1 = vexRT[Ch3];
 else Y1 = 0;
  if(abs(vexRT[Ch1]) > threshold)X2 = vexRT[Ch1];
 else X2 = 0;
  if(abs(vexRT[Ch4]) > threshold)X1 = vexRT[Ch4];
 else X1 = 0;

motor[leftDrive] = Y1 + X2;
motor[rightDrive] = Y1 - X2;
  motor[leftStrafe] = X1;
  motor[rightStrafe] = X1;
  }
}

Sword 1.0

Initial design for Bot A "Sword" 15x15x15 inches

Drive Train: H drive, 4x 3-wire motor (3:1), 2x 269 (2:1)

Lift: Double-chain-bar lift, 4x 393 (Speed) (3:1)
Bucket: Feeder chain with standoffs and chain ends

























Design Review:
-Does not meet height requirement, "Shield" must be able to score high goal
-Drive train is unstable, warping causes inconsistency in control
-Concern arises from being pushed from the front, develop a more robust feeding mechanism

08_31_2012 :: First Meeting






Strategy and Brainstorming Session

Key Takeaways
- Focus on speed and collecting a lot of sacks
- Fundraising
- What parts to order
- Elementary school outreach
- Descoring
- Hoarding bot
- How do we descore opponent's high goal
- Review rules

2011-2012 VEX Competition Season After-Action Review (AAR)



Task: At the conclusion of the 2011-2012 Vex Competition Season, the members of C.O.R.E. conducted an after action review in order to pass down lessons learned from this season to future club members. This process is used in order to analyze what happened, why it happened, and how it can be done better, by the participants and those responsible for the project. The results of this AAR will be critical in the preparation for the 2012/2013 VEX Competition Season.

In Attendance
Members of the Mt.SAC C.O.R.E:
Kevin Chavez, Stephen Espinoza, James Lam, Hamed Nichi, Patrix Stanley, Vincent Vendiola,
Aaron Victoria, Alejandro Weiner, Kyle Yu, and Michelle Zazueta

Location: Mount San Antonio College VEX Room, Building 61, Room 3361*
Date: 21 April 2012
Primary Task Reviewed: VEX Competition Season

Sustain: What did we do well?
§  Scouting the event to be comfortable with the surroundings 
§  Cooperation with OCC/CSUN, when our cortex malfunctioned, we borrowed their cortexes in order to compete. We showed gratitude and support for their teams in order to keep connections
§  Assigning tasks during the competition
§  Getting ideas from other schools and networking
§  Budget Management and working with the parts we already have
§  Made practice field from spare parts
§  Proving our design was plausible
§  Cross-check each other. Wake up calls in the morning and make sure everyone is on schedule

 Improve: What can we do better?
§  Time management
§  Start the engineering notebook early
§  Do not make major last minute changes to the robot or programming. There is not enough time between competitions to test.
§  Finish the mechanical work early so programmers have time to develop a full program
§  Communication: Agree as a team, don’t take things personal, be respectful, “freshmen effect” – poor cooperation and communication inherent in rookie teams,  don’t put down people’s ideas or opinions without research
§  Provide strict deadlines
§  At competition, track personnel: make sure you let people know where you are going if you leave the pit so we don’t have to scramble to find you
§  Leave the pit early enough to avoid running, VEX competitions usually run AHEAD of schedule. Be mindful of surroundings: when moving from the pit to the field, have people designated to hold on to the robot(s)
§  Top teams did designs we originally thought were unfeasible, test every idea!
§  Finish one robot before jumping to another
§  Do not split into two groups for each robot, we are one team.
§  Define leadership roles

Lessons Learned: Programming/Mechanical/Leadership
§  Test sensors separately prior to mounting
§  Limit motors used on the power expander, 4 at a time is a was a difficult load
§  Faraday Cage: Metal surrounding the VEXnet key limits reception at a distance. Use a USB A to B cable to mount the key high and away from metal.
§  Design Note: Ability to strafe without purchasing mecanum wheels
§  Have a low center of gravity to avoid tipping
§  Consider the ease of repair when designing, especially replacing clutches
§  Spread out the load on the brain to avoid frying it. Do not put heavy motors on ports 1-4 only.
§  Be comfortable with competition rules. Do not risk being out of spec; a few top teams in the finals round was disqualified for this.
§  Stay away from line sensors; they are too slow. Prefer quadratic encoders

Future Plans to Sustain the Club
§  Success book
§  Camera
§  Inventory, Clean, and Organize VEX Room
§  Collaborate with other local colleges for scrimmages
§  Build a low-cost practice field