Robot::Autonomous Class Reference

The Autonomous class contains classes and functions related to the robot's autonomous behavior. More...

#include <auton.h>

Public Types
enum	AUTON_ROUTINE {   RED_NEG = 1 , RED_POS = 2 , RED_POS_LATE_RUSH = 3 , BLUE_POS = -1 ,   BLUE_POS_LATE_RUSH = -2 , BLUE_NEG = -3 , SKILLS = 0 }

Public Member Functions
void	AutoDrive (Intake &intake, Latch &latch, Sweeper &sweeper, DistanceSensor &distance, LadyBrown &ladybrown)
	Drives the robot autonomously.

Static Public Member Functions
static void	AutonSwitcher (int autonNum)
	Switches the autonomous program.

Static Public Attributes
static AUTON_ROUTINE	auton = RED_POS
	Sets the number of the autonomous program to use.
static std::string	autonName = "Red Positive"
	The name of the autonomous program.

Private Member Functions
void	RedNeg (Intake &intake, Latch &latch, DistanceSensor &distance)
	Runs the autonomous path for the far side defensive game strategy.
void	RedPos (Intake &intake, Latch &latch, Sweeper &sweeper, DistanceSensor &distance, LadyBrown &ladybrown)
	Runs the autonomous path for the near side offensive game strategy.
void	RedPosLateGoalRush (Intake &intake, Latch &latch, Sweeper &sweeper, DistanceSensor &distance, LadyBrown &ladybrown)
void	BluePos (Intake &intake, Latch &latch, Sweeper &sweeper, DistanceSensor &distance, LadyBrown &ladybrown)
	Runs the puncher routine for the Skills Challenge.
void	BluePosLateGoalRush (Intake &intake, Latch &latch, Sweeper &sweeper, DistanceSensor &distance, LadyBrown &ladybrown)
void	BlueNeg (Intake &intake, Latch &latch, DistanceSensor &distance)
	Runs the autonomous path for the far side offensive game strategy. This function executes the autonomous path for the far side offensive game strategy. It contains the specific actions and movements required for this strategy.
void	Skills (Intake &intake, Latch &latch, DistanceSensor &distance, LadyBrown &ladybrown)

Detailed Description

The Autonomous class contains classes and functions related to the robot's autonomous behavior.

We use Lemlib extensively for our documentation. You can find the documentation for Lemlib at Lemlib documentation.

Definition at line 16 of file auton.h.

Member Enumeration Documentation

AUTON_ROUTINE

enum Robot::Autonomous::AUTON_ROUTINE

Enumerator
RED_NEG
RED_POS
RED_POS_LATE_RUSH
BLUE_POS
BLUE_POS_LATE_RUSH
BLUE_NEG
SKILLS

Definition at line 18 of file auton.h.

{ RED_NEG = 1, RED_POS = 2, RED_POS_LATE_RUSH = 3, BLUE_POS = -1, BLUE_POS_LATE_RUSH = -2, BLUE_NEG = -3, SKILLS = 0 };

Member Function Documentation

AutoDrive()

void Autonomous::AutoDrive	(	Intake &	intake,
		Latch &	latch,
		Sweeper &	sweeper,
		DistanceSensor &	distance,
		LadyBrown &	ladybrown )

Drives the robot autonomously.

This function drives the robot autonomously based on the selected autonomous program. It takes a reference to a Puncher object and a boolean value indicating whether to use autonomous mode.

Parameters

puncher	A reference to the Puncher object.
autono	A boolean value indicating whether to use autonomous mode.

Definition at line 295 of file autons.cpp.

                                                 {
   // Keep the switcher running while the controller down button has not been pressed and the time period is not
   // autonomous Compare the current auton value to run the auton routine
   switch (Autonomous::auton) {
   case RED_NEG:
      Autonomous::autonName = "Red Negative";
      RedNeg(intake, latch, distance);
      break;
   case RED_POS:
      Autonomous::autonName = "Red Positive";
      RedPos(intake, latch, sweeper, distance, ladybrown);
      break;
   case RED_POS_LATE_RUSH:
      Autonomous::autonName = "Red Positive Late Rush";
      RedPosLateGoalRush(intake, latch, sweeper, distance, ladybrown);
      break;
   case BLUE_POS:
      Autonomous::autonName = "Blue Positive";
      BluePos(intake, latch, sweeper, distance, ladybrown);
      break;
   case BLUE_NEG:
      Autonomous::autonName = "Blue Negative";
      BlueNeg(intake, latch, distance);
      break;
   case BLUE_POS_LATE_RUSH:
      Autonomous::autonName = "Blue Positive Late Rush";
      BluePosLateGoalRush(intake, latch, sweeper, distance, ladybrown);
      break;
   case SKILLS:
      Autonomous::autonName = "Skills";
      Skills(intake, latch, distance, ladybrown);
      break;
   }
}

References auton, autonName, BLUE_NEG, BLUE_POS, BLUE_POS_LATE_RUSH, BlueNeg(), BluePos(), BluePosLateGoalRush(), RED_NEG, RED_POS, RED_POS_LATE_RUSH, RedNeg(), RedPos(), RedPosLateGoalRush(), SKILLS, and Skills().

AutonSwitcher()

void Autonomous::AutonSwitcher ( int autonNum )

static

Switches the autonomous program.

This function switches the autonomous program to the next available program. It allows the user to cycle through different autonomous programs during runtime.

Definition at line 331 of file autons.cpp.

                                           {
   switch (autonNum) {
   case 1:
      Autonomous::autonName = "Red Negative";
      Autonomous::auton = RED_NEG;
      break;
   case 2:
      Autonomous::autonName = "Red Positive Sweep";
      Autonomous::auton = RED_POS;
      break;
   case 3:
      Autonomous::autonName = "Red Positive Late Rush";
      Autonomous::auton = RED_POS_LATE_RUSH;
      break;
   case -1:
      Autonomous::autonName = "Blue Positive Sweep";
      Autonomous::auton = BLUE_POS;
      break;
   case -2:
      Autonomous::autonName = "Blue Positive Late Rush";
      Autonomous::auton = BLUE_POS_LATE_RUSH;
      break;
   case -3:
      Autonomous::autonName = "Blue Negative";
      Autonomous::auton = BLUE_NEG;
      break;
   case 0:
      Autonomous::autonName = "Skills";
      Autonomous::auton = SKILLS;
   }
   std::cout << "Current auton: " + Autonomous::autonName << std::endl;
}

References auton, autonName, BLUE_NEG, BLUE_POS, BLUE_POS_LATE_RUSH, RED_NEG, RED_POS, RED_POS_LATE_RUSH, and SKILLS.

BlueNeg()

void Autonomous::BlueNeg ( Intake & intake, Latch & latch, DistanceSensor & distance )

private

Runs the autonomous path for the far side offensive game strategy. This function executes the autonomous path for the far side offensive game strategy. It contains the specific actions and movements required for this strategy.

Todo

Make the autonomous more fleshed out, building it properly for the competition

Definition at line 277 of file autons.cpp.

                                                                               {
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0, 0);
   // Move to first stake, then a bit farther at a slower speed for alignment
   chassis.moveToPoint(0, -27, 1800, {.forwards = false, .maxSpeed = 60}, true);
   chassis.moveToPoint(0, -35, 2050, {.forwards = false, .maxSpeed = 30}, true);
   chassis.waitUntilDone();
   pros::delay(500);
   // Grab the closest MOGO mech
   LatchControl.extend();
   pros::delay(2000);
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
   pros::delay(3000);
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), and Robot::Globals::LatchControl().

Referenced by AutoDrive().

BluePos()

void Autonomous::BluePos ( Intake & intake, Latch & latch, Sweeper & sweeper, DistanceSensor & distance, LadyBrown & ladybrown )

private

Runs the puncher routine for the Skills Challenge.

This function executes the puncher routine for the Skills Challenge. It takes a reference to a Puncher object and performs the necessary actions for the challenge.

Parameters

puncher

A reference to the Puncher object.

Definition at line 81 of file autons.cpp.

                                                                                                                       {
 
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0,0);
 
   // Move to first stake
   chassis.moveToPose(0, -28, 0, 2000, {.forwards = false});
   chassis.waitUntilDone();
   // Grab the closest MOGO mech
   latch.toggle();
   pros::delay(250);
 
   // Rotate toward blue ring
   chassis.turnToPoint(25, -27, 1000);
   chassis.waitUntilDone();
 
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
   // Moves to 2 ring stack
 
   chassis.moveToPoint(25, -27, 1250, {.forwards = true});
   chassis.turnToPoint(33.5, 6, 1000);
   SweeperControl.extend();
   chassis.moveToPoint(35, 7, 1500);
   chassis.waitUntilDone();
   IntakeMotor.move_velocity(0);
   HookMotor.move_velocity(0);
 
   chassis.moveToPose(25, -4, 170, 2000, {.horizontalDrift = 2});
   chassis.moveToPoint(32, 10, 1000, {.forwards = false});
   chassis.waitUntilDone();
   latch.toggle();
 
   chassis.turnToPoint(-14, -36, 800);
   SweeperControl.retract();
   ladybrown.MoveToPoint(LadyBrown::LOAD_STATE);
 
   chassis.moveToPoint(-14, -36, 5000);
 
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), Robot::LadyBrown::LOAD_STATE, Robot::LadyBrown::MoveToPoint(), Robot::Globals::SweeperControl(), and Robot::Latch::toggle().

Referenced by AutoDrive().

BluePosLateGoalRush()

void Autonomous::BluePosLateGoalRush ( Intake & intake, Latch & latch, Sweeper & sweeper, DistanceSensor & distance, LadyBrown & ladybrown )

private

Definition at line 124 of file autons.cpp.

                                                                                                                                   {
      // drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   // chassis.setPose(-36, 11,-17);
 
   // IntakeMotor.move_velocity(600);
   // chassis.moveToPoint(-49, 38.5, 1100, {.minSpeed=60}, false);
   // chassis.moveToPose(-47, 47, -5, 1000, {.horizontalDrift=8, .earlyExitRange=2}, true);
 
 
   // chassis.waitUntil(37);
   // SweeperControl.extend();
 
   // chassis.waitUntilDone();
 
   // pros::delay(200);
 
   // chassis.moveToPoint(-48, 8, 1500, {.forwards=false, .maxSpeed=90}, false);
 
   // SweeperControl.retract();
 
   // chassis.turnToPoint(-24, 38.5, 750, {.forwards=false});
   // chassis.moveToPoint(-24, 38.5, 1100, {.forwards=false, .maxSpeed=65});
   // chassis.moveToPoint(-22, 40.5, 550, {.forwards=false, .maxSpeed=50});
 
   // LatchControl.extend();
 
   // chassis.turnToPoint(-24, 4, 600, {.forwards=true});
   // chassis.moveToPoint(-24, 4, 1200, {.maxSpeed=90});
   // chassis.waitUntil(8);
   // HookMotor.move_velocity(200);
 
   // chassis.turnToPoint(-12, 45, 1100, {.forwards=true}, false);
 
   // chassis.moveToPoint(-12, 45, 1150, {.maxSpeed=60});
 
   // chassis.turnToHeading(90, 650);
 
   // SweeperControl.extend();
   
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0,0);
 
   // Move to first stake
   chassis.moveToPose(0, -28, 0, 2000, {.forwards = false});
   chassis.waitUntilDone();
   // Grab the closest MOGO mech
   latch.toggle();
   pros::delay(250);
 
   // Rotate toward blue ring
   chassis.turnToPoint(25, -27, 1000);
   chassis.waitUntilDone();
 
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
   // Moves to 2 ring stack
   chassis.moveToPoint(25, -27, 1250, {.forwards = true});
   chassis.turnToPoint(25, 0, 1000, {.forwards = false});
   chassis.waitUntilDone();
 
   // Moves goal to corner
   chassis.moveToPoint(28, 3, 1250, {.forwards = false});
   chassis.waitUntilDone();
 
   HookMotor.brake();
   latch.toggle();
 
   // Move to Third goal
   chassis.moveToPoint(25, -30, 1500, {.forwards = true},true);
   chassis.turnToPoint(25, -40, 1000, {.forwards = false});
   chassis.moveToPoint(25, -38,1000, {.forwards = false});
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), and Robot::Latch::toggle().

Referenced by AutoDrive().

RedNeg()

void Autonomous::RedNeg ( Intake & intake, Latch & latch, DistanceSensor & distance )

private

Runs the autonomous path for the far side defensive game strategy.

This function executes the autonomous path for the far side defensive game strategy. It contains the specific actions and movements required for this strategy.

Definition at line 22 of file autons.cpp.

                                                                              {
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0, 0);
   // Move to first stake, then a bit farther at a slower speed for alignment
   chassis.moveToPoint(0, -27, 1800, {.forwards = false, .maxSpeed = 60}, true);
   chassis.moveToPoint(0, -35, 2050, {.forwards = false, .maxSpeed = 30}, true);
   chassis.waitUntilDone();
   pros::delay(500);
   // Grab the closest MOGO mech
   LatchControl.extend();
   pros::delay(1500);
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
   pros::delay(3000);
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), and Robot::Globals::LatchControl().

Referenced by AutoDrive().

RedPos()

void Autonomous::RedPos ( Intake & intake, Latch & latch, Sweeper & sweeper, DistanceSensor & distance, LadyBrown & ladybrown )

private

Runs the autonomous path for the near side offensive game strategy.

This function executes the autonomous path for the near side offensive game strategy. It contains the specific actions and movements required for this strategy.

Definition at line 39 of file autons.cpp.

                                                                                                                      {
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0,0);
 
   // Move to first stake
   chassis.moveToPose(0, -28, 0, 2000, {.forwards = false});
   chassis.waitUntilDone();
   // Grab the closest MOGO mech
   latch.toggle();
   pros::delay(250);
 
   // Rotate toward blue ring
   chassis.turnToPoint(-25, -27, 1000);
   chassis.waitUntilDone();
 
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
   // Moves to 2 ring stack
 
   chassis.moveToPoint(-25, -27, 1250, {.forwards = true});
   chassis.turnToPoint(-33.5, 6, 1000);
   SweeperControl.extend();
   chassis.moveToPoint(-35, 7, 1500);
   chassis.waitUntilDone();
   IntakeMotor.move_velocity(0);
   HookMotor.move_velocity(0);
 
   chassis.moveToPose(-25, -4, 170, 2000, {.horizontalDrift = 2});
   chassis.moveToPoint(-32, 10, 1000, {.forwards = false});
   chassis.waitUntilDone();
   latch.toggle();
 
   chassis.turnToPoint(14, -36, 800);
   SweeperControl.retract();
   ladybrown.MoveToPoint(LadyBrown::LOAD_STATE);
 
   chassis.moveToPoint(14, -36, 5000);
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), Robot::LadyBrown::LOAD_STATE, Robot::LadyBrown::MoveToPoint(), Robot::Globals::SweeperControl(), and Robot::Latch::toggle().

Referenced by AutoDrive().

RedPosLateGoalRush()

void Autonomous::RedPosLateGoalRush ( Intake & intake, Latch & latch, Sweeper & sweeper, DistanceSensor & distance, LadyBrown & ladybrown )

private

Definition at line 199 of file autons.cpp.

                                                                                                                                  {
      // drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   // chassis.setPose(-36, 11,-17);
 
   // IntakeMotor.move_velocity(600);
   // chassis.moveToPoint(-49, 38.5, 1100, {.minSpeed=60}, false);
   // chassis.moveToPose(-47, 47, -5, 1000, {.horizontalDrift=8, .earlyExitRange=2}, true);
 
 
   // chassis.waitUntil(37);
   // SweeperControl.extend();
 
   // chassis.waitUntilDone();
 
   // pros::delay(200);
 
   // chassis.moveToPoint(-48, 8, 1500, {.forwards=false, .maxSpeed=90}, false);
 
   // SweeperControl.retract();
 
   // chassis.turnToPoint(-24, 38.5, 750, {.forwards=false});
   // chassis.moveToPoint(-24, 38.5, 1100, {.forwards=false, .maxSpeed=65});
   // chassis.moveToPoint(-22, 40.5, 550, {.forwards=false, .maxSpeed=50});
 
   // LatchControl.extend();
 
   // chassis.turnToPoint(-24, 4, 600, {.forwards=true});
   // chassis.moveToPoint(-24, 4, 1200, {.maxSpeed=90});
   // chassis.waitUntil(8);
   // HookMotor.move_velocity(200);
 
   // chassis.turnToPoint(-12, 45, 1100, {.forwards=true}, false);
 
   // chassis.moveToPoint(-12, 45, 1150, {.maxSpeed=60});
 
   // chassis.turnToHeading(90, 650);
 
   // SweeperControl.extend();
   
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0,0);
 
   // Move to first stake
   chassis.moveToPose(0, -28, 0, 2000, {.forwards = false});
   chassis.waitUntilDone();
   // Grab the closest MOGO mech
   latch.toggle();
   pros::delay(250);
 
   // Rotate toward blue ring
   chassis.turnToPoint(-25, -27, 1000);
   chassis.waitUntilDone();
 
   // Load the ring onto the stake
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
   // Moves to 2 ring stack
   chassis.moveToPoint(-25, -27, 1250, {.forwards = true});
   chassis.turnToPoint(-25, 0, 1000, {.forwards = false});
   chassis.waitUntilDone();
 
   // Moves goal to corner
   chassis.moveToPoint(-28, 3, 1250, {.forwards = false});
   chassis.waitUntilDone();
   HookMotor.brake();
   latch.toggle();
 
   // Move to Third goal
   chassis.moveToPoint(-25, -30, 1500, {.forwards = true},true);
   chassis.turnToPoint(-25, -40, 1000, {.forwards = false});
   chassis.moveToPoint(-25, -38,1000, {.forwards = false});
}

References Robot::Globals::chassis(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), and Robot::Latch::toggle().

Referenced by AutoDrive().

Skills()

void Autonomous::Skills ( Intake & intake, Latch & latch, DistanceSensor & distance, LadyBrown & ladybrown )

private

Executes the Skills challenge autonomous.

This function controls the robot's actions during autonomous routine 5. It takes references to the Intake and Latch objects as parameters.

Parameters

intake	The reference to the Intake object.
latch	The reference to the Latch object.

Definition at line 13 of file skills.cpp.

                                                                                                    {
   
   // Set pre-constants 
   HookMotor.set_zero_position(HookMotor.get_position());
   colorSensor.set_led_pwm(70);
   drive_.set_brake_mode_all(pros::E_MOTOR_BRAKE_BRAKE);
   chassis.setPose(0, 0, 0);
 
   // Autonomous routine for the Skills challenge - 60 seconds MAX
   /* ##############################################*/
 
   // De-hook into the alliance stake
   HookMotor.move_relative(230, 200);
   pros::delay(750);
 
   //Move to the center, then turn to and touch the right side Mogo.
   chassis.moveToPoint(0, 14, 800);
   chassis.turnToPoint(19, 15, 650, {.forwards = false});
   chassis.moveToPoint(16.5, 15, 850, {.forwards = false, .earlyExitRange=2}, false);
   chassis.moveToPoint(19, 15, 550, {.forwards = false, .maxSpeed=63}, false);
 
   //Latch the mogo - delays just in case
   LatchControl.extend();
   pros::delay(250);
 
   //Turn to the above ring - Start intake and hook, and move there
   chassis.turnToPoint(24, 38.75, 850, {}, false);
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(150);
   chassis.moveToPoint(24, 38.75, 1000);
 
   // Immediately move to the farthest ring. A couple of other things happen while this is going on
   chassis.moveToPose(48, 90, 0, 2050, {.horizontalDrift = 8, .lead = 0.4, .earlyExitRange=2}, true);
   //Checks between 10-45 inches of movement for if the hook got stuck on the mogo flower
   for (int i = 10; i<45; i += 5) {
   chassis.waitUntil(i);
   std::cout << "velocity" << HookMotor.get_actual_velocity() << std::endl;
   //Checks every 5 inches for if the hook gets stuck.
   while (HookMotor.get_actual_velocity() < 25 && !(colorSensor.get_hue() < 30 && colorSensor.get_hue() > 8)) {
      //FIX: The hook is lifted back and then hit into the target to ensure fit.
      HookMotor.move_velocity(-200);
      pros::delay(150);
      HookMotor.move_velocity(100);
      pros::delay(350);
   }
   //Lift up the Lady brown to load onto at 40 inches from the last position.
   }
   
   chassis.waitUntil(50);
   
 
   //Set the hook to a high-torque rpm to get the best loading possible, waits for the MoveToPose to end.
   HookMotor.move_velocity(175);
   chassis.waitUntilDone();
   //Turn to a point ~1.5 tiles away from the right neutral stake
   ladybrown.MoveToPoint(LadyBrown::LOAD_STATE);
   chassis.turnToPoint(40, 62.5, 800, {.forwards=false});
 
 
   //Actually move there
   chassis.moveToPoint(40, 62.5, 1500, {.forwards=false}, true);
 
   //Immediately hit against the lady brown to ensure appropriate fit.
   // Wait until 20 inches passed to get to the point behind the lady brown - stop the hook here.
   chassis.waitUntil(30);
   HookMotor.brake();
 
   chassis.waitUntilDone();
 
   //Turn to the Neutral wall stake.
   chassis.turnToPoint(78, 62.5, 600);
 
   // Move there
   chassis.moveToPoint(72, 62.5, 900, {.forwards=true, .maxSpeed=50}, true);
 
   // At 18 inches of movement, stop the intake in advance of the neutral wall stake
   chassis.waitUntil(18);
   IntakeMotor.brake();
 
   chassis.waitUntilDone();
 
   //Allow the robot to settle, then move the lady brown to score on the neutral stake.
 
   ladybrown.MoveToPoint(LadyBrown::ATTACK_STATE);
 
   //Move back to the 5th tile edge, and restart the intake 15 inches into the movement.
   chassis.moveToPoint(47, 62.5, 750, {.forwards = false, .maxSpeed = 75});
   chassis.waitUntil(5);
 
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
   //Point the robot towards the home side wall, and put the lady brown down.
   chassis.turnToPoint(47, 0, 950);
   ladybrown.MoveToPoint(LadyBrown::BASE_STATE);
 
   //Go close to the wall, but exit early so that the robot glides to the last ring.
   chassis.moveToPoint(47, 0, 2500, {.forwards = true, .maxSpeed = 45, .earlyExitRange=2});
 
   //Start the hook at a higher speed rpm
   HookMotor.move_velocity(200);
 
   // Start at 10 inches into the movement - schedule a check every 5 inches for if the hook is stuck.
   chassis.waitUntil(10);
   for (int i = 12; i<47; i += 5) {
      chassis.waitUntil(i);
      std::cout << "velocity" << HookMotor.get_actual_velocity() << std::endl;
      while (HookMotor.get_actual_velocity() < 25 && !(colorSensor.get_hue() < 30 && colorSensor.get_hue() > 8)) {
         //FIX: The hook is lifted back and then hit into the target to ensure fit.
         HookMotor.move_velocity(-200);
         pros::delay(150);
         HookMotor.move_velocity(125);
         pros::delay(350);
      }
   }
 
   chassis.waitUntilDone();
   //Wait for two seconds at the edge to ensure rings get put onto the mogo.
   pros::delay(1000);
 
   //Turn, then Move to the point where the last ring was nudged to collect it for top ring
   chassis.turnToPoint(61, 17, 1000);
   chassis.moveToPoint(61, 17, 1000, {.forwards = true, .maxSpeed = 50, .earlyExitRange=4});
 
 
   //Turn away to position the mogo in the corner, waiting to let the hook put all items onto the mogo.
   chassis.turnToHeading(-30, 1000, {.direction = AngularDirection::CCW_COUNTERCLOCKWISE}, false);
   pros::delay(1000);
   //Let the last ring go when the hook gets stuck
   HookMotor.move_velocity(-200);
   //Let the mogo go
   LatchControl.retract();
 
   //Move back a little to ensure the mogo goes into the corner.
   chassis.moveToPoint(64.5, 5, 1000, {.forwards = false, .maxSpeed = 50, .earlyExitRange=1.5}, false);
 
   // Stop the intake and hook.
   IntakeMotor.brake();
   HookMotor.brake();
   
   //Move to the top edge of the first tile, preparing for alignment. Then move back into the wall to use the distance sensor to reorient.
   chassis.moveToPose(48, 20, -90, 1000, {.forwards = true, .horizontalDrift=9}, true);
   chassis.moveToPoint(67, 20, 1350, {.forwards = false}, false);
 
   // Get the distance to the wall using the distance sensor, convert to inches and add the distance to tracking center (5in).
   // Then, set the new position
   //float new_x = (float)(72 - 8);
   float new_x = (float)(72 - 8);
   float new_y = ((float)(distance.get_distance()) / (float)10 / (float)2.54 + (float)6.5 - (float)8.75);
   std::cout << "Distance: " << new_x << std::endl;
   std::cout << "Distance: " << (float)(72) / (float)10 / (float)2.54 << std::endl;
   std::cout << "Distance: " << distance.get_distance() << std::endl;
   chassis.setPose(new_x, new_y, chassis.getPose().theta);
   chassis.moveToPoint(chassis.getPose().x-5, chassis.getPose().y, 600, {.earlyExitRange=1});
 
   chassis.moveToPose(24, 15, -90, 1000, {.horizontalDrift = 8});
   
   
   chassis.turnToHeading(90, 1000, {});
   chassis.moveToPoint(-16.5, 15, 1000, {.forwards = false, .maxSpeed=80}, false);
   chassis.moveToPoint(-20.5, 15, 700, {.forwards = false, .maxSpeed=55}, false);
 
   //Latch the mogo - delays just in case
   LatchControl.extend();
   pros::delay(250);
 
   //Turn to the above ring - Start intake and hook, and move there
   chassis.turnToPoint(-24, 38.75, 850, {}, false);
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
   chassis.moveToPoint(-24, 38.75, 1000);
 
   // Immediately move to the farthest ring. A couple of other things happen while this is going on
   chassis.moveToPose(-48, 90, 0, 2050, {.horizontalDrift = 8, .lead = 0.4}, true);
   //Checks between 10-45 inches of movement for if the hook got stuck on the mogo flower
   for (int i = 10; i<45; i += 5) {
   chassis.waitUntil(i);
   std::cout << "velocity" << HookMotor.get_actual_velocity() << std::endl;
   //Checks every 5 inches for if the hook gets stuck.
   while (HookMotor.get_actual_velocity() < 25 && !(colorSensor.get_hue() < 30 && colorSensor.get_hue() > 8)) {
      //FIX: The hook is lifted back and then hit into the target to ensure fit.
      HookMotor.move_velocity(-200);
      pros::delay(150);
      HookMotor.move_velocity(100);
      pros::delay(350);
   }
   //Lift up the Lady brown to load onto at 40 inches from the last position.
   }
 
   //Set the hook to a high-torque rpm to get the best loading possible, waits for the MoveToPose to end.
   chassis.waitUntil(50);
 
   HookMotor.move_velocity(110);
 
   chassis.waitUntilDone();
   //Turn to a point ~1.5 tiles away from the right neutral stake
   ladybrown.MoveToPoint(LadyBrown::LOAD_STATE);
   chassis.turnToPoint(-40, 62.5, 800, {.forwards=false});
 
   //Actually move there
   chassis.moveToPoint(-40, 62.5, 1500, {.forwards=false}, true);
 
   //Immediately hit against the lady brown to ensure appropriate fit.
   chassis.waitUntil(30);
   HookMotor.brake();
 
   // Wait until 20 inches passed to get to the point behind the lady brown - stop the hook here.
 
   chassis.waitUntilDone();
 
   //Turn to the Neutral wall stake.
   chassis.turnToPoint(-78, 61.5, 660);
 
   // Move there
   chassis.moveToPoint(-72, 61.5, 920, {.forwards=true, .maxSpeed=50}, true);
 
   // At 18 inches of movement, stop the intake in advance of the neutral wall stake
   chassis.waitUntil(18);
   IntakeMotor.brake();
 
   chassis.waitUntilDone();
 
   //Allow the robot to settle, then move the lady brown to score on the neutral stake.
   ladybrown.MoveToPoint(LadyBrown::ATTACK_STATE);
 
   //Move back to the 5th tile edge, and restart the intake 15 inches into the movement.
   chassis.moveToPoint(-47, 63.5, 750, {.forwards = false, .maxSpeed = 75});
   chassis.waitUntil(5);
   IntakeMotor.move_velocity(600);
   HookMotor.move_velocity(200);
 
 
   //Point the robot towards the home side wall, and put the lady brown down.
   chassis.turnToPoint(-47, 0, 950);
   ladybrown.MoveToPoint(LadyBrown::BASE_STATE);
 
   //Go close to the wall, but exit early so that the robot glides to the last ring.
   chassis.moveToPoint(-47, -5, 2750, {.forwards = true, .maxSpeed = 45, .earlyExitRange=2});
 
   //Start the hook at a higher speed rpm
   HookMotor.move_velocity(200);
 
   // Start at 10 inches into the movement - schedule a check every 5 inches for if the hook is stuck.
   chassis.waitUntil(10);
   for (int i = 12; i<47; i += 5) {
      chassis.waitUntil(i);
      std::cout << "velocity" << HookMotor.get_actual_velocity() << std::endl;
      while (HookMotor.get_actual_velocity() < 25 && !(colorSensor.get_hue() < 30 && colorSensor.get_hue() > 8)) {
         //FIX: The hook is lifted back and then hit into the target to ensure fit.
         HookMotor.move_velocity(-200);
         pros::delay(150);
         HookMotor.move_velocity(125);
         pros::delay(350);
      }
   }
 
   chassis.waitUntilDone();
   //Wait for two seconds at the edge to ensure rings get put onto the mogo.
   pros::delay(1000);
 
   //Turn, then Move to the point where the last ring was nudged to collect it for top ring
   chassis.turnToPoint(-62, 17, 1000);
   chassis.moveToPoint(-62, 17, 2000, {.forwards = true, .maxSpeed = 50, .earlyExitRange=4});
 
 
   //Turn away to position the mogo in the corner, waiting to let the hook put all items onto the mogo.
   chassis.turnToHeading(30, 1000, {}, false);
   pros::delay(1300);
   //Let the last ring go when the hook gets stuck
   HookMotor.move_velocity(-200);
   pros::delay(200);
   //Let the mogo go
   LatchControl.retract();
 
   //Move back a little to ensure the mogo goes into the corner.
   chassis.moveToPoint(-64, 6, 1000, {.forwards = false, .maxSpeed = 50, .earlyExitRange=1.5}, false);
 
   // Stop the intake and hook.
   IntakeMotor.brake();
   HookMotor.brake();
   
   //Move to the top edge of the first tile, preparing for alignment. Then move back into the wall to use the distance sensor to reorient.
   chassis.moveToPose(-48, 20, -90, 2050, {.forwards = true, .maxSpeed = 80},  true);
 
}

References Robot::LadyBrown::ATTACK_STATE, Robot::LadyBrown::BASE_STATE, Robot::Globals::chassis(), Robot::Globals::colorSensor(), Robot::Globals::drive_(), Robot::Globals::HookMotor(), Robot::Globals::IntakeMotor(), Robot::Globals::LatchControl(), Robot::LadyBrown::LOAD_STATE, and Robot::LadyBrown::MoveToPoint().

Referenced by AutoDrive().

Member Data Documentation

auton

Autonomous::AUTON_ROUTINE Autonomous::auton = RED_POS

static

Sets the number of the autonomous program to use.

This function allows the user to specify the autonomous program to be executed by the robot. The autonomous program number determines the specific actions and movements the robot will perform.

Parameters

auton

The number of the autonomous program to use.

Definition at line 28 of file auton.h.

Referenced by AutoDrive(), autonomous(), and AutonSwitcher().

autonName

std::string Autonomous::autonName = "Red Positive"

static

The name of the autonomous program.

This variable stores the name of the autonomous program currently selected. It is handled by the switching functions and the screen.

Definition at line 35 of file auton.h.

Referenced by AutoDrive(), and AutonSwitcher().

---

The documentation for this class was generated from the following files:

• include/robot/auton.h
• src/routines/autons.cpp
• src/routines/skills.cpp