Movements

Functions with Okapi Units

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry, without slew.

p_target is in an okapi length unit.
speed is 0 to 127. It's recommended to keep this at 110.

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set(24_in, 110);
  chassis.pid_wait();
}

Example

void pid_odom_set(okapi::QLength p_target, int speed);

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry.

p_target is in an okapi length unit.
speed is 0 to 127. It's recommended to keep this at 110.
slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set(24_in, 110, true);
  chassis.pid_wait();
}

Example

void pid_odom_set(okapi::QLength p_target, int speed, bool slew_on);

pid_odom_set()

Go to an xy coordinate without slew. This is a wrapper for pid_odom_ptp_set().

p_imovement united_pose, expecting {0_in, 0_in}

Prototype

void pid_odom_set(united_odom p_imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24_in, 24_in}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_set()

Go to an xy coordinate with slew. This is a wrapper for pid_odom_ptp_set().

p_imovement united_pose, expecting {0_in, 0_in} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_set(united_odom p_imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24_in, 24_in}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points without slew. The path will switch to boomerang is angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

p_imovements vector of united_pose

Prototype

void pid_odom_set(std::vector{united_odom} p_imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                      {{24_in, 24_in}, fwd, 110}});
chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points. The path will switch to boomerang is angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

p_imovements vector of united_pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_set(std::vector{united_odom} p_imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                      {{24_in, 24_in}, fwd, 110}},
                     true);
chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate without slew.

p_imovement united_pose, expecting {0_in, 0_in}

Prototype

void pid_odom_ptp_set(united_odom p_imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_ptp_set({{24_in, 24_in}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate with slew.

p_imovement united_pose, expecting {0_in, 0_in} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_ptp_set(united_odom p_imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_ptp_set({{24_in, 24_in}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

p_imovements vector of united_pose

Prototype

void pid_odom_pp_set(std::vector{united_odom} p_imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_pp_set({{{0_in, 24_in}, fwd, 110},
                           {{24_in, 24_in}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

p_imovements vector of united_pose
slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_pp_set(std::vector{united_odom} p_imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_pp_set({{{0_in, 24_in}, fwd, 110},
                           {{24_in, 24_in}, fwd, 110}}, 
                           true);
  chassis.pid_wait();
}

pid_odom_injected_pp_set()

Creates a new path that injects points between the input points, then pure pursuits along this new path.

p_imovements vector of united_pose

Prototype

void pid_odom_injected_pp_set(std::vector{united_odom} p_imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_injected_pp_set({{{0_in, 24_in}, fwd, 110},
                                    {{24_in, 24_in}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_injected_pp_set()

Creates a new path that injects points between the input points, then pure pursuits along this new path.

p_imovements vector of united_pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_injected_pp_set(std::vector{united_odom} p_imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_injected_pp_set({{{0_in, 24_in}, fwd, 110},
                                    {{24_in, 24_in}, fwd, 110}}, 
                                    true);
  chassis.pid_wait();
}

pid_odom_smooth_pp_set()

Creates a new path that injects points between the input points, then smooths the corners of this path, then pure pursuits along this new path.

p_imovements vector of united_pose

Prototype

void pid_odom_smooth_pp_set(std::vector{united_odom} p_imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_smooth_pp_set({{{0_in, 24_in}, fwd, 110},
                                  {{24_in, 24_in}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_smooth_pp_set()

Creates a new path that injects points between the input points, then smooths the corners of this path, then pure pursuits along this new path.

p_imovements vector of united_pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_smooth_pp_set(std::vector{united_odom} p_imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_smooth_pp_set({{{0_in, 24_in}, fwd, 110},
                                  {{24_in, 24_in}, fwd, 110}}, 
                                  true);
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

p_imovement united_pose, expecting {0_in, 0_in, 0_deg}

Prototype

void pid_odom_boomerang_set(united_odom p_imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24_in, 24_in, 0_deg}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

p_imovement united_pose, expecting {0_in, 0_in, 0_deg} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_boomerang_set(united_odom p_imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24_in, 24_in, 0_deg}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses okapi units dir face the point fwd or rev speed 0 to 127, max speed during motion

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12_in, 12_in}, fwd, 110);
  chassis.pid_wait();
}

Example

void pid_turn_set(united_pose p_itarget, drive_directions dir, int speed);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses okapi units dir face the point fwd or rev speed 0 to 127, max speed during motion
slew_on ramp up from a lower speed to your target speed

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12_in, 12_in}, fwd, 110, true);
  chassis.pid_wait();
}

Example

void pid_turn_set(united_pose p_itarget, drive_directions dir, int speed, bool slew_on);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses okapi units dir face the point fwd or rev speed 0 to 127, max speed during motion
behavior changes what direction the robot will turn. can be left, right, shortest, longest, raw

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12_in, 12_in}, fwd, 110, ez::longest);
  chassis.pid_wait();
}

Example

void pid_turn_set(united_pose p_itarget, drive_directions dir, int speed, e_angle_behavior behavior);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses okapi units dir face the point fwd or rev speed 0 to 127, max speed during motion
behavior changes what direction the robot will turn. can be left, right, shortest, longest, raw
slew_on ramp up from a lower speed to your target speed

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12_in, 12_in}, fwd, 110, ez::longest, true);
  chassis.pid_wait();
}

Example

void pid_turn_set(united_pose p_itarget, drive_directions dir, int speed, e_angle_behavior behavior, bool slew_on);

pid_wait_until_point()

Lock the code in a while loop until this point has been passed.

target {x, y} pose with units for the robot to pass through before the while loop is released

Prototype

void pid_wait_until_point(united_pose target);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until_point({12_in, 24_in});  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}

pid_wait_until()

Lock the code in a while loop until this point has been passed.

target {x, y} pose with units for the robot to pass through before the while loop is released

Prototype

void pid_wait_until(united_pose target);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until({12_in, 24_in});  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}

Functions Without Okapi Units

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry, without slew.

target double, expecting inches speed is 0 to 127. It's recommended to keep this at 110.

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set(24, 110);
  chassis.pid_wait();
}

Example

void pid_odom_set(double target, int speed);

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry.

target double, expecting inches speed is 0 to 127. It's recommended to keep this at 110.
slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set(24, 110, true);
  chassis.pid_wait();
}

Example

void pid_odom_set(double target, int speed, bool slew_on);

pid_odom_set()

Go to an xy coordinate without slew. This is a wrapper for pid_odom_ptp_set().

imovement pose, expecting {0, 0}

Prototype

void pid_odom_set(odom imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24, 24}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_set()

Go to an xy coordinate with slew. This is a wrapper for pid_odom_ptp_set().

imovement pose, expecting {0, 0} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_set(odom imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24, 24}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points without slew. The path will switch to boomerang is angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

imovements vector of united_pose

Prototype

void pid_odom_set(std::vector{odom} imovements)

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

chassis.pid_odom_set({{{0, 24}, fwd, 110},
                      {{24, 24}, fwd, 110}});
chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points. The path will switch to boomerang is angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

imovements vector of pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_set(std::vector{odom} imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

chassis.pid_odom_set({{{0, 24}, fwd, 110},
                      {{24, 24}, fwd, 110}},
                     true);
chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate without slew.

imovement pose, expecting {0, 0}

Prototype

void pid_odom_ptp_set(odom imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_ptp_set({{24, 24}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate with slew.

imovement united_pose, expecting {0_in, 0_in} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_ptp_set(odom imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_ptp_set({{24, 24}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

imovements vector of pose

Prototype

void pid_odom_pp_set(std::vector{odom} imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_pp_set({{{0, 24}, fwd, 110},
                           {{24, 24}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given with slew.

imovements vector of united_pose
slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_pp_set(std::vector{odom} imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_pp_set({{{0, 24}, fwd, 110},
                           {{24, 24}, fwd, 110}}, 
                           true);
  chassis.pid_wait();
}

pid_odom_injected_pp_set()

Creates a new path that injects points between the input points, then pure pursuits along this new path.

imovements vector of pose

Prototype

void pid_odom_injected_pp_set(std::vector{odom} imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_injected_pp_set({{{0, 24}, fwd, 110},
                                    {{24, 24}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_injected_pp_set()

Creates a new path that injects points between the input points, then pure pursuits along this new path.

imovements vector of pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_injected_pp_set(std::vector{odom} imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_injected_pp_set({{{0, 24}, fwd, 110},
                                    {{24, 24}, fwd, 110}}, 
                                    true);
  chassis.pid_wait();
}

pid_odom_smooth_pp_set()

Creates a new path that injects points between the input points, then smooths the corners of this path, then pure pursuits along this new path.

imovements vector of pose

Prototype

void pid_odom_smooth_pp_set(std::vector{odom} imovements);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_smooth_pp_set({{{0, 24}, fwd, 110},
                                  {{24, 24}, fwd, 110}});
  chassis.pid_wait();
}

pid_odom_smooth_pp_set()

Creates a new path that injects points between the input points, then smooths the corners of this path, then pure pursuits along this new path.

imovements vector of pose slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_smooth_pp_set(std::vector{odom} imovements, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_smooth_pp_set({{{0, 24}, fwd, 110},
                                  {{24, 24}, fwd, 110}}, 
                                  true);
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

imovement united_pose, expecting {0, 0, 0}

Prototype

void pid_odom_boomerang_set(odom imovement);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24, 24, 0}, fwd, 110});
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

imovement united_pose, expecting {0, 0, 0} slew_on increases the speed of the drive gradually. You must set slew constants for this to work!

Prototype

void pid_odom_boomerang_set(odom imovement, bool slew_on);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.odom_odom_set({{24, 24,  0}, fwd, 110}, true);
  chassis.pid_wait();
}

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face dir face the point fwd or rev speed 0 to 127, max speed during motion

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12, 12}, fwd, 110);
  chassis.pid_wait();
}

Example

void pid_turn_set(pose itarget, drive_directions dir, int speed);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face dir face the point fwd or rev speed 0 to 127, max speed during motion
slew_on ramp up from a lower speed to your target speed

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12, 12}, fwd, 110, true);
  chassis.pid_wait();
}

Example

void pid_turn_set(pose p_itarget, drive_directions dir, int speed, bool slew_on);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face dir face the point fwd or rev speed 0 to 127, max speed during motion
behavior changes what direction the robot will turn. can be left, right, shortest, longest, raw

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12, 12}, fwd, 110, ez::longest);
  chassis.pid_wait();
}

Example

void pid_turn_set(pose p_itarget, drive_directions dir, int speed, e_angle_behavior behavior);

pid_turn_set()

Sets the robot to turn face a point using PID and odometry.

p_itarget {x, y} a target point to face dir face the point fwd or rev speed 0 to 127, max speed during motion
behavior changes what direction the robot will turn. can be left, right, shortest, longest, raw
slew_on ramp up from a lower speed to your target speed

Prototype

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_turn_set({12, 12}, fwd, 110, ez::longest, true);
  chassis.pid_wait();
}

Example

void pid_turn_set(pose p_itarget, drive_directions dir, int speed, e_angle_behavior behavior, bool slew_on);

pid_wait_until_index()

Lock the code in a while loop until this point has been passed.

index index of your input points, 0 is the first point in the index

Prototype

void pid_wait_until_index(int index);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until_index(1);  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}

pid_wait_until_index_started()

Lock the code in a while loop until this point becomes the target.

index index of your input points, 0 is the first point in the index

Prototype

void pid_wait_until_index_started(int index);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until_index_started(1);  // Waits until the target becomes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}

pid_wait_until_point()

Lock the code in a while loop until this point has been passed.

target {x, y} pose for the robot to pass through before the while loop is released

Prototype

void pid_wait_until_point(pose target);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until_point({12, 24});  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}

pid_wait_until()

Lock the code in a while loop until this point has been passed.

target {x, y} pose for the robot to pass through before the while loop is released

Prototype

void pid_wait_until(pose target);

Example

void autonomous() {
  chassis.pid_targets_reset();                // Resets PID targets to 0
  chassis.drive_imu_reset();                  // Reset gyro position to 0
  chassis.drive_sensor_reset();               // Reset drive sensors to 0
  chassis.odom_xyt_set(0_in, 0_in, 0_deg);    // Set the current position, you can start at a specific position with this
  chassis.drive_brake_set(MOTOR_BRAKE_HOLD);  // Set motors to hold.  This helps autonomous consistency

  chassis.pid_odom_set({{{0_in, 24_in}, fwd, 110},
                        {{12_in, 24_in}, rev, 110},
                        {{24_in, 24_in}, rev, 110}},
                       true);
  chassis.pid_wait_until({12, 24});  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}