Example #1
0
void autonomous()
{

	int encoder1 = digitalRead (1);
	int limit2 = digitalRead (2);

intakeDead();
//turnRightDead();
//delay (500);
driveForwardDead();
delay (1000);



	stopIntake();
	driveBackDead();
	delay (2000);
	turnRight(500);
	outtakeDead (3000);



if (encoder1 < 300 ) // bottom  is activated
{
	stopIntake();
	driveBackDead();
	delay (2000);
	turnRight(500);
	outtakeDead (1000);

}
else
	stopIntake();
	driveBackDead();
	delay (2000);

	stopAll(20000);


//rushBlue ();
//allLine (99999);

// all jumper comands here:





}
Example #2
0
void rejectionRed()
{
	// variables
		int armMin = 300;
		int wallHeight = 1000;
		int goalHeight = 1550;
		int pot = analogRead (8);


		int encoder1 = 1200; //drive under wall
		int encoder2 = 136; // rotate 90 degrees
		int encoder3 = 900; // backwards to the opponets goal
		int encoder4 = 150; //rotate 90
		int encoder5 = 200; // ass towards bridge


		// begin routine

		intakeDead(); // unfold
		delay(300); // needs to clear the wall..
		driveBack (encoder1); // drive backwards to under the bridge
		stopIntake();
		turnRight (encoder2); // turn ass to opponets goal
		driveBack (encoder3); // drive to opponets goal
		turnRight (encoder4); // ass to bridge
		armUp(wallHeight);// arm up
		driveBack(encoder5); // block their launch

		stopAll ();

}
/* Psuedocode
Ramp Forward -> [Cross Barrier] -> Raise Arm HIGH -> Hold Arm HIGH -> Ramp Zero -> [Reach Goal] -> Outtake -> [Finish Outtake]
-> Stop Intake -> Ramp Forward -> Ramp Zero -> [Reach Barrier] -> Lower Arm LOW -> Ramp Backward -> [Reach Square] -> Hard Zero
Wait Until Press -> Raise Arm BARRIER -> Hold Arm BARRIER -> Ramp Forward -> Ramp Zero -> [Reach Barrier] -> Ramp Backward
-> [Reach Square] -> Hard Zero -> Wait Until Press -> Ramp Forward -> Ramp Zero -> [Reach Barrier]
*/
void Alex() // Caches preload (5) + Knocks 2 big balls (10)
{
	deploy();
	moveStraight(1, 0, 1550); // 1600 is just before goal...changed for some reason
	lift(HIGH); // only accurate to the nearest 100... may need to adjust HIGH value
	holdArm();
	moveStraight(1, 0, 300); // reaches goal
	//wait1Msec(1000);
	intake(false);
	wait1Msec(1000); // outtake
	stopIntake();
	moveStraight(-1, 0, 400); // move back away from goal...Apparently Safety is greater than move forward
	liftDown();
	moveStraight(-1, 0, 1500);
	waitForButton();
	lift(BARRIER);
	holdArm();
	intake(false);
	moveStraight(1, 0, 550); // estimated guess based on 10Q's values - WORKS
	wait1Msec(300);
	moveStraight(-1, 0, 550);
	waitForButton();
	moveStraight(1, 0, 950); // A bit of trouble... Not sure if you want to spin rollers for this hit...
	wait1Msec(300); // outtaking pushes the ball away + needs good aiming
	moveStraight(-1, 0, 950);
	resetValues(100);
}
Example #4
0
void rushBlue()
{

	// variables
	int armMin = 300;
	int wallHeight = 1000;
	int goalHeight = 1700;
	int pot = analogRead(8);
	int midLine = analogRead(2);

	int encoder1 = 1800; //drive under wall
	int encoder2 = 130; // rotate 90 degrees
	int encoder3 = 1400; // backwards to the opponets goal
	int encoder4 = 630; //turn to goal + enclose it

	// begin routine

	intakeDead(); // unfold
	delay(300); // needs to clear the wall..
	driveBack(encoder1); // drive backwards to under the bridge
	stopIntake();
	turnLeft(encoder2); // turn ass to opponets goal
	driveBackDead(encoder3); // drive to opponets goal
	delay(500);

	midLine = 3000;
	while (midLine > 2000)
	{
		midLine = analogRead(2);
	}

	motorSet(MOTOR_DRIVE_RIGHT_BACK, 10); // no inertia
	motorSet(MOTOR_DRIVE_RIGHT_FRONT, 10);
	motorSet(MOTOR_ARM_LEFT_BACK, 10);
	motorSet(MOTOR_ARM_LEFT_FRONT, 10);
	delay(85);

	//driveBackDead(); // push them
	//delay (300);
	stopDrive();
	delay(7000); // wait till auto end
	driveBackDead(); // push them
	delay(800);
	stopDrive();
	delay(100);
	driveForwardDead(); // driveback towards goal
	delay(300);
	stopDrive();
	intakeDead();
	armUp(goalHeight); //arm up
	scrapeLeft(encoder4);  //encase the goal
	driveForwardSlowDead();
	delay(700);
	stopDrive();
	outtake(3000);

	stopAll();

}
Example #5
0
void kakitRed ()
{

// variables
	int armMin = 300;
	int wallHeight = 1000;
	int goalHeight = 1550;
	int dead1 = 1000;
	int dead2 = 2000;
	int dead3 = 3000;
	int pot = analogRead (8);


	int encoder1 = 1000;
	int encoder2 = 150;
	int encoder3 = 2000;
	int encoder4 = 75;
	int encoder5 = 75;
	int encoder6 = 75;
	int encoder7 = 75;
	int encoder8 = 75;
	int encoder9 = 75;


	// begin routine
	driveForwardDead (); //ram big balls
	intakeDead ();
	delay (3000);
	stopIntake();
	driveBackDead (4000); // wall align to 90 deg
	driveForward (encoder1);
	turnRight (encoder2); // turn towards buckys
	intakeDead ();
	//line follow forward (encoder 4)

	driveBackSlowDead (); // allign the bump
	driveBackDead();  // over the bump
	driveForwardSlowDead(); // alighn to bump
	driveBackSlow(encoder4);
	turnRight (encoder5);
	driveBackSlow (encoder6) ; // go under the bridge
	armUpDead (); // break the bridge
	delay(500);
	armDown (armMin);
	driveBack (encoder7);
	turnRight (encoder8);
	armUp (goalHeight);
	//line follow (encoder9);
	outtake(8000); // score all three balls in the goal

	stopAll ();

}
	void redDevansh() // Places preload (1-2) + 2 buckies (2-4) + TURN LEFT Knocks buckies (1-6) + Places two Balls (2)
	{
			deploy();
			intake(true);
			wait10Msec(10);
			moveStraight(1, 0, 150); // 200 estimated based on 10Q values
			wait10Msec(50);
			moveStraight(-1, 0, 150);
			stopIntake();
			waitForButton();
			lift(BUMP);
			holdArm();
			intake(false);
			waitForButton();
			resetValues(0);
			liftDown();
			wait10Msec(20);
			intake(true);
			moveStraight(1, 0, (TILE + HALF_TILE)); // theory
			wait10Msec(50); // intake ball hopefully
			lift(BUMP);
			holdArm();
			stopIntake();
			spin(0, -1, RIGHT_ANGLE); // RED SIDE TURN LEFT knocks buckies hopefully
			wait10Msec(30);
			intake(false); // outtake ball hopefully
			wait10Msec(300);
			stopIntake();
			spin(0, 1, RIGHT_ANGLE);
			liftDown();
			intake(true);
			moveStraight(1, 0, (TILE + HALF_TILE)); // theory
			lift(BUMP);
			holdArm();
			stopIntake();
			spin(0, -1, RIGHT_ANGLE); // RED SIDE TURN LEFT
			wait10Msec(30);
			intake(false);
			resetValues(10);
	}
Example #7
0
void ram()

{
	intakeDead(); // unfold

	driveForwardDead();
	delay(5000);
	stopDrive();
	stopIntake();

	stopAll();

}
void pickUpBall(int goals)
{
	resetValues(0);
	intake(true);
	wait10Msec(30);
	int current = 0;
	while(current < goals * 250)
	{
		setLeft(25); setRight(25);
		current = nMotorEncoder[LeftMWheel];
	}
	stopIntake();
	setLeft(0); setRight(0);
}
Example #9
0
void worldsBlue ()
{

// variables
	int armMin = 300;
	int wallHeight = 100;
	int goalHeight = 1550;
	int dead1 = 1000;
	int dead2 = 2000;
	int dead3 = 3000;
	int pot = analogRead (8);


	int encoder1 = 1500; //drive under wall
	int encoder2 = 136; // rotate 90 degrees
	int encoder3 = 900; // backwards to the opponets goal
	int encoder4 = 400; //turn to goal + enclose it


	// begin routine

	intakeDead(); // unfold
	delay(300); // needs to clear the wall..
	driveBack (encoder1); // drive backwards to under the bridge
	stopIntake();
	turnLeft (encoder2); // turn ass to opponets goal
	driveBack (encoder3); // drive to opponets goal
	driveBackDead(); // push them
	delay (200);
	stopDrive ();
	delay (7000); // wait till auto end
	driveBackDead ();// push them
	delay (600);
	stopDrive();
	delay(100);
	driveForwardDead(); // driveback towards goal
	delay(400);
	stopDrive ();
	armUp(goalHeight); //arm up
	scrapeLeft (encoder4);  //encase the goal
	outtake (300);

	stopAll ();

}
Example #10
0
void reverse15Red()
{
	// variables
			int armMin = 300;
			int wallHeight = 1000;
			int goalHeight = 1550;
			int pot = analogRead (8);


			int encoder1 = 1200; //drive under wall
			int encoder2 = 136; // rotate 90 degrees
			int encoder3 = 1300; // backwards to the opponets goal
			int encoder4 = 900; //turn to bridge
			int encoder5 = 200; // knock their wallball
			int encoder6 = 200; // turn to other ball
			int encoder7 = 400; // knock their center ball
			int encoder8 = 400; // positioning



			// begin routine

			intakeDead(); // unfold
			delay(300); // needs to clear the wall..
			driveBack (encoder1); // drive backwards to under the bridge
			stopIntake();
			turnRight (encoder2); // turn ass to opponets goal
			driveBack (encoder3); // drive to opponets goal
			driveBackDead(); // 90 deg align
			delay(400);
			stopDrive ();
			armUp(wallHeight);// arm up
			scrapeLeft (encoder4); // turn to wall ball
			driveForward (encoder5); // knock off wall ball
			scrapeLeftBack(encoder6); // turn to middle ball
			driveForward(encoder7); // knock off middle ball
			driveBack (encoder8); // positioning

			stopAll ();




}
Example #11
0
void intakeControl()
{
	// Intake for 1 controller.
	if(vexRT[Btn5D] == 1 && vexRT[Btn5U] == 0)
	{
		// Intake roller inward.
		motor[intakeTread] = currentIntakeSpeed;
		motor[intakeWheel] = currentIntakeSpeed;
	}
	else if(vexRT[Btn5D] == 0 && vexRT[Btn5U] == 1)
	{
		// Intake roller outward.
		motor[intakeTread] = -currentIntakeSpeed;
		motor[intakeWheel] = -currentIntakeSpeed;
	}
	else
	{
		// Stop intake roller movement.
		stopIntake();
	}
}
Example #12
0
void rejectionBlueSkills()
{

	// variables
	int armMin = 300;
	int wallHeight = 1000;
	int goalHeight = 1700;
	int pot = analogRead(8);
	int midLine = analogRead(2);

	int encoder1 = 1800; //drive under wall
	int encoder2 = 130; // rotate 90 degrees
	int encoder3 = 1400; // backwards to the opponets goal
	int encoder4 = 270; //turn to center of large balls
	int encoder5 = 200; //hit 1st blue ball off
	int encoder55 = 300; // back a bit
	int encoder6 = 450; //hit 2nd ball off
	int encoder7 = 450; // drive back past line
	int encoder8 = 160; // turn to line

	// begin routine

	intakeDead(); // unfold
	delay(300); // needs to clear the wall..
	driveBack(encoder1); // drive backwards to under the bridge
	stopIntake();
	turnLeft(encoder2); // turn ass to opponets goal
	driveBackDead(encoder3); // drive to opponets goal
	delay(500);

	midLine = 3000;
	while (midLine > 2000)
	{
		midLine = analogRead(2);
	}

	motorSet(MOTOR_DRIVE_RIGHT_BACK, 10); // no inertia
	motorSet(MOTOR_DRIVE_RIGHT_FRONT, 10);
	motorSet(MOTOR_ARM_LEFT_BACK, 10);
	motorSet(MOTOR_ARM_LEFT_FRONT, 10);
	delay(85);

	armUp(wallHeight); // arm up
	turnRight(encoder4); // turn towards center of large balls
	driveForwardSlowDead(); // go between large balls
	delay(1200);
	stopDrive();
	delay(300);
	turnLeft(encoder5); //hit center ball
	driveBackSlow(encoder55);
	turnRight(encoder6); // hit far ball
	driveBackSlow(encoder7); // back up past line
	turnRight(encoder8); // tun to line

	armUp(goalHeight);

	findLineLeft();
	//followLine(300);

	driveForwardDead(); // drive to goal
	delay(700);
	stopDrive();
	outtake(3000);

	stopAll();
	delay(60000);

}
Example #13
0
void kakitRed()
{

// variables
	int armMin = 300;
	int wallHeight = 1000;
	int goalHeight = 1650;

	int pot = analogRead(8);

	int encoder00 = 250; // back up abit to row
	int encoder0 = 950; // turn 360 degrees, knock off buckys, face line
	int encoder1 = 162; // rotate towards 2 buckys
	int encoder2 = 150; // drive towards buckys
	int encoder3 = 400; // back up to bump
	int encoder4 = 200; // back up towards bridge
	int encoder5 = 360; // rotate 180 degrees to the large ball
	int encoder6 = 900; // go under bridge and knock out large ball
	int encoder7 = 90; // turn to goal
	int encoder8 = 200; // drive to goal
	int encoder9 = 75;

	// begin routine
	intake(300);
	armDownTrim();

	driveForwardDead(); //ram big balls
	delay(1500);
	stopDrive();
	delay(500);

	driveBack(encoder00); // back up to row abit
	intakeDead();

	turnLeft(encoder0); // turn 360 degrees

	driveBackDead(); // drive back + wall align
	delay(1300);
	stopDrive();
	delay(500);

	turnRight(encoder1); // turn to two buckys
	intakeDead();

	followLine(300); // make sure ur straight

	driveForwardSlowDead(); // drive towards buckys
	delay(500);
	stopDrive();
	delay(600);

	driveForwardDead(); //get the 2nd ball
	delay(200);
	stopDrive();
	delay(600);

	stopIntake();

	driveBack(encoder3); // back up to bump

	armUpDead(); // armup
	delay(50);
	stopArm();
	stopIntake();

	driveBackSlowDead(); // allign the bump
	delay(300);
	stopDrive();
	delay(500);

	driveBackDead();  // over the bump
	delay(1000);
	stopDrive();
	delay(500);

	driveForwardSlowDead(); // alighn to bump
	delay(800);
	stopDrive();
	delay(500);

	driveBackSlow(encoder4); // back up towards bridge
	turnLeft(encoder5); // rotate 180 degrees to the large ball
	armDown(armMin);
	armDownTrim();

	driveForward(encoder6); // go under the bridge + knock large ball
	armUp(goalHeight);

	turnRight(encoder7); // turn to goal

	findLineRight();
	followLine(300);

	driveForwardSlowDead(); // drive to goal
	delay(700);
	stopDrive();
	outtake(7000); // outtake 3

	stopAll();

}
Example #14
0
void rejectionBlue()
{

	// variables
	int armMin = 300;
	int wallHeight = 1000;
	int goalHeight = 1700;
	int pot = analogRead(8);
	int midLine = analogRead(2);

	int encoder1 = 1800; //drive under wall
	int encoder2 = 130; // rotate 90 degrees
	int encoder3 = 1400; // backwards to the opponets goal
	int encoder4 = 100; //turn to goal + enclose it
	int encoder5 = 450; //hit 1st blue ball off
	int encoder6 = 350; // drive back
	int encoder7 = 175; // turn to 2nd blue ball
	int encoder8 = 550; // hit 2nd ball off
	int encoder9 = 250; // drive back to position
	int encoder10 = 370; // rotate to line

	// begin routine

	intakeDead(); // unfold
	delay(300); // needs to clear the wall..
	driveBack(encoder1); // drive backwards to under the bridge
	stopIntake();
	turnLeft(encoder2); // turn ass to opponets goal
	driveBackDead(encoder3); // drive to opponets goal
	delay(500);

	midLine = 3000;
	while (midLine > 2000)
	{
		midLine = analogRead(2);
	}

	motorSet(MOTOR_DRIVE_RIGHT_BACK, 10); // no inertia
	motorSet(MOTOR_DRIVE_RIGHT_FRONT, 10);
	motorSet(MOTOR_ARM_LEFT_BACK, 10);
	motorSet(MOTOR_ARM_LEFT_FRONT, 10);
	delay(85);

	armUp(wallHeight); // arm up
	turnRight(encoder4); // turn towards center blue ball
	driveForward(encoder5); // hit 1st ball off
	delay(700);
	driveBack(encoder6); // back
	delay(700);
	turnRight(encoder7); // turn towards 2nd blue ball
	delay(700);
	driveForward(encoder8); // hit off 2nd blue ball
	delay(700);
	intakeDead();
	driveBack(encoder9); // position
	delay(700);
	turnLeft(encoder10); // encase opponet goal
	delay(700);
	armUp(goalHeight);

	findLineRight();
	//followLine(300);

	driveForwardDead(); // drive to goal
	delay(700);
	stopDrive();
	outtake(3000);

	stopAll();
	delay(60000);

}
Example #15
0
void classic15Blue()
{
	int armMin = 290;
	int wallHeight = 1000;
	int goalHeight = 1700;
	int dead1 = 1200;
	int dead2 = 2000;
	int dead3 = 3000;
	int pot = analogRead(8);

	//encoder values
	int encoder1 = 900; //drive to goal
	int encoder2 = 325; //keep going towards goal
	int encoder3 = 0; //drive slow, adjust to 90 degrees
	int encoder4 = 325; //back up
	int encoder5 = 1350; //back up across the barrier again
	int encoder6 = 80; // turn towards center large ball
	int encoder7 = 600; // hit 1st ball off the barrier
	int encoder8 = 350; // drive back
	int encoder9 = 200; // turn towards other large ball
	int encoder10 = 400; // hit 2nd ball off the barrier
	int encoder11 = 300; // drive back to square
	int encoder12 = 290; // turn to barf
	int encoder13 = 800; // drive to barf + pickup
	int encoder14 = 400;
	int encoder15 = 700;

	// begin routine

	intakeDead();
	delay(1000);
	stopIntake();

	// driveforward (some curve)////////////////////////////////////////////////////
	int counts = 0;
	imeReset(0); // rest rightLine I.M.E
	imeGet(0, &counts);

	while (abs(counts) < encoder1)
	{
		motorSet(MOTOR_DRIVE_RIGHT_BACK, 110); // slight curve cuz friction
		motorSet(MOTOR_DRIVE_RIGHT_FRONT, 110);
		motorSet(MOTOR_ARM_LEFT_BACK, 127);
		motorSet(MOTOR_ARM_LEFT_FRONT, 127);

		imeGet(0, &counts); // keep getting the value
	}

	motorSet(MOTOR_DRIVE_RIGHT_BACK, 0);
	motorSet(MOTOR_DRIVE_RIGHT_FRONT, 0);
	motorSet(MOTOR_ARM_LEFT_BACK, 0);
	motorSet(MOTOR_ARM_LEFT_FRONT, 0);
	delay(200);

///////////////////////////////////////////////////////////////////////////////

	//driveForward(encoder1); // drive to goal
	armUp(goalHeight); //raise arm after cross barrier
	driveForwardSlow(encoder2);  //keep going towards goal
	driveForwardSlowDead(); //drive slow, adjust to 90 degrees
	delay(1000);
	outtake(1700); // outtake
	driveBack(encoder4); // back up
	delay(300);
	armDown(armMin); // lower arm
	driveBack(encoder5); //back up across the barrier again
	delay(300);
	turnLeft(encoder6); // turn towards center large ball
	armUp(wallHeight); // arm up to wall height
	driveForward(encoder7); // hit it off the barrier
	delay(500);
	driveBack(encoder8); // drive back
	delay(300);
	turnRight(encoder9); // turn towards other large ball
	driveForward(encoder10); // hit 2nd ball off the barrier
	delay(500);
	driveBack(encoder11); // drive back to square
	delay(600);
	turnLeft(encoder12); // turn to barf
	delay(300);
	armDown(armMin);
	intakeDead(); // pick up barf
	driveForward(encoder13); // drive towards barf + intake it
	delay(500);

	//end of routine

	stopAll();
	delay(60000); ///////////////////////////////////////////////////////////////////////////////////

}
Example #16
0
task autonomous()
{
	switch(selectedAuton)
	{
		case Autonomous_LeftScoreMatchLoads:
			{
				clearEncoders();

				motor[intakeTread]  = -127;
				motor[intakeWheel] = -127;

				wait1Msec(700);

				stopIntake();

				positionArm(Arm_ScoreHeight);

				stopArm();

				wait1Msec(1000);

				int leftDest = SensorValue[encoder_Left] + 2200;

				while(SensorValue[encoder_Left] < leftDest)
				{
					driveAtSpeed(60);
				}

				stopDrive();

				motor[intakeTread]  = 127;
				motor[intakeWheel] = 127;

				wait10Msec(200);
			}
			break;

		case Autonomous_RightPickupScoreYellow:
			{
				clearEncoders();

				int leftDest = SensorValue[encoder_Left] + 1850;

				while(SensorValue[encoder_Left] < leftDest)
				{
					driveAtSpeed(50);
				}

				stopDrive();

				motor[intakeTread]  = -127;
				motor[intakeWheel] = -127;

				wait1Msec(1000);

				stopIntake();

				positionArm(Arm_ScoreHeight);

				int rightDest = SensorValue[encoder_Right] - 730;

				while(SensorValue[encoder_Right] > rightDest)
				{
					motor[driveLeftBack] = 38;
					motor[driveRightBack] = 0;
					motor[driveLeftFront] = 38;
					motor[driveRightFront] = 0;
				}

				leftDest = SensorValue[encoder_Left] + 650;

				while(SensorValue[encoder_Left] < leftDest)
				{
					motor[driveLeftBack] = 38;
					motor[driveRightBack] = 40;
					motor[driveLeftFront] = 38;
					motor[driveRightFront] = 40;
				}

				stopDrive();

				motor[intakeTread]  = 127;
				motor[intakeWheel] = 127;

				wait1Msec(1500);

				stopIntake();
			}
			break;

			case Autonomous_ProgrammingSkills:
				{
					clearEncoders();

					int leftDest = SensorValue[encoder_Left] + 1850;

					while(SensorValue[encoder_Left] < leftDest)
					{
						driveAtSpeed(50);
					}

					stopDrive();

					motor[intakeTread]  = -127;
					motor[intakeWheel] = -127;

					wait1Msec(1000);

					stopIntake();

					positionArm(Arm_ScoreHeight);

					int rightDest = SensorValue[encoder_Right] - 730;

					while(SensorValue[encoder_Right] > rightDest)
					{
						motor[driveLeftBack] = 38;
						motor[driveRightBack] = 0;
						motor[driveLeftFront] = 38;
						motor[driveRightFront] = 0;
					}

					leftDest = SensorValue[encoder_Left] + 650;

					while(SensorValue[encoder_Left] < leftDest)
					{
						driveAtSpeed(40);
					}

					stopDrive();

					motor[intakeTread] = 127;
					motor[intakeWheel] = 127;

					wait1Msec(500);

					stopIntake();

					leftDest = SensorValue[encoder_Left] - 390;

					while(SensorValue[encoder_Left] > leftDest)
					{
						driveAtSpeed(-30);
					}

					stopDrive();

					positionArm(990);

					stopArm();

					rightDest = SensorValue[encoder_Right] + 660;

					while(SensorValue[encoder_Right] < rightDest)
					{
						motor[driveLeftBack] = -30;
						motor[driveLeftFront] = -30;
					}

					stopDrive();

					leftDest = SensorValue[encoder_Left] - 2050;

					while(SensorValue[encoder_Left] > leftDest)
					{
						driveAtSpeed(-50);
					}

					stopDrive();
				}
				break;

			case Autonomous_None:
			default:
				{
				}
				break;
	}
}
Example #17
0
void classic15Red()
{
		int armMin = 300;
		int wallHeight = 1000;
		int goalHeight = 1550;
		int dead1 = 1000;
		int dead2 = 2000;
		int dead3 = 3000;
		int pot = analogRead (8);

	//encoder values
		int encoder1 = 1125; //drive to goal
		int encoder2 = 325; //keep going towards goal
		int encoder3 = 0; //drive slow, adjust to 90 degrees
		int encoder4 = 275; //back up
		int encoder5 = 800; //back up across the barrier again
		int encoder6 = 90; // turn towards center large ball
		int encoder7 = 220; // hit it off the barrier
		int encoder8 = 350; // drive back
		int encoder9 = 110; // turn towards other large ball
		int encoder10 = 681; // hit it off the barrier
		int encoder11 = 300; // drive back to square
		int encoder12 = 150; // ass to wall
		int encoder13 = 800;
		int encoder14 = 400;
		int encoder15 = 700;
		int encoder16 = 400;
		int encoder17 = 100;
		int encoder18 = 400;
		int encoder19 = 700;
		int encoder20 = 400;
		int encoder21 = 100;
		int encoder22 = 400;
		int encoder23 = 700;

	// begin routine

	intakeDead();
	delay(1000);
	stopIntake();
	driveForward(encoder1); // drive to goal
	armUp (goalHeight); //raise arm after cross barrier
	driveForwardSlow(encoder2);  //keep going towards goal
	driveForwardSlowDead (dead1); //drive slow, adjust to 90 degrees
	outtake (1500);
	driveBack(encoder4); // back up
	armDown(armMin); // lower arm
	driveBack(encoder5); //back up across the barrier again
	turnRight(encoder6); // turn towards center large ball
	armUp(wallHeight); // arm up to wall height
	driveForward(encoder7); // hit it off the barrier
	driveBack(encoder8); // drive back
	turnLeft(encoder9); // turn towards other large ball
	driveForward(encoder10); // hit it off the barrier
	driveBackSlowDead (dead2);  // drive back to square
	turnLeftArc (encoder12); // ass to wall
	driveBackSlowDead (dead2) ; // wall align 90degrees
	armDown (armMin); // arm down to floor
	intakeDead (); // start intaking
	driveForwardSlow (encoder13) ;// drive towards barf and intake whatever
	turnRightArc (encoder14); // rotate towards the barrier
	stopIntake();
	armUp(wallHeight); // arm up to wall height
	driveForwardSlow (encoder15); // drive to barrier
	stopDrive(); // stop at barrier
	outtake (1500); //drop the barf
	driveBackSlowDead(dead2); //hump da bump
	armDown (armMin); // arm down to floor
	intakeDead (); //start intaking
	turnLeftArc (encoder16); //face the barf
	driveForwardSlow (encoder17) ;// drive towards barf and intake whatever
	turnRightArc (encoder18) ; // rotate towards the barrier
	stopIntake();
	armUp(wallHeight); // arm up to wall height
	driveForwardSlow (encoder19); // drive to barrier
	stopDrive(); // stop at barrier
	outtake (1500); //drop the barf
	driveBackSlowDead(dead2); //drive to and align on bump
	armDown (armMin); // arm down to floor
	intakeDead (); //start intaking
	turnLeftArc (encoder20); //face the barf
	driveForwardSlow (encoder21) ;// drive towards barf and intake whatever
	turnRightArc (encoder22) ; // rotate towards the barrier
	stopIntake();
	armUp(wallHeight); // arm up to wall height
	driveForwardSlow (encoder23); // drive to barrier
	outtake (1500); //drop the barf



	//end of routine




	stopAll () ;
	delay(60000);///////////////////////////////////////////////////////////////////////////////////


}
void deploy()
{
	intake(true);
	wait1Msec(300);
	stopIntake();
}