Movements

Functions with Units

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry, using slew only if it is enabled globally.

p_target is in a 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.pid_odom_set(24_in, 110);
  chassis.pid_wait();
}

Example

void pid_odom_set(ez::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 a 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.pid_odom_set(24_in, 110, true);
  chassis.pid_wait();
}

Example

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

pid_odom_set()

Go to an xy coordinate, using slew only if it is enabled globally. If the point has an angle this runs boomerang, otherwise it runs injected pure pursuit. This is a wrapper for pid_odom_boomerang_set() and pid_odom_injected_pp_set().

p_imovement united_odom, expecting {{0_in, 0_in}, ez::fwd, 110}

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.pid_odom_set({{24_in, 24_in}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_set()

Go to an xy coordinate. If the point has an angle this runs boomerang, otherwise it runs injected pure pursuit. This is a wrapper for pid_odom_boomerang_set() and pid_odom_injected_pp_set().

p_imovement united_odom, expecting {{0_in, 0_in}, ez::fwd, 110} 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.pid_odom_set({{24_in, 24_in}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points, using slew only if it is enabled globally. The path will switch to boomerang if an angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

p_imovements vector of united_odom

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}, ez::fwd, 110},
                      {{24_in, 24_in}, ez::fwd, 110}});
chassis.pid_wait();
}

pid_odom_set()

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

p_imovements vector of united_odom 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}, ez::fwd, 110},
                      {{24_in, 24_in}, ez::fwd, 110}},
                     true);
chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate, using slew only if it is enabled globally.

p_imovement united_odom, expecting {{0_in, 0_in}, ez::fwd, 110}

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}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate with slew.

p_imovement united_odom, expecting {{0_in, 0_in}, ez::fwd, 110} 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}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

p_imovements vector of united_odom

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}, ez::fwd, 110},
                           {{24_in, 24_in}, ez::fwd, 110}});
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

p_imovements vector of united_odom
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}, ez::fwd, 110},
                           {{24_in, 24_in}, ez::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_odom

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}, ez::fwd, 110},
                                    {{24_in, 24_in}, ez::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_odom 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}, ez::fwd, 110},
                                    {{24_in, 24_in}, ez::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_odom

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}, ez::fwd, 110},
                                  {{24_in, 24_in}, ez::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_odom 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}, ez::fwd, 110},
                                  {{24_in, 24_in}, ez::fwd, 110}}, 
                                  true);
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

p_imovement united_odom, expecting {{0_in, 0_in, 0_deg}, ez::fwd, 110}

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.pid_odom_boomerang_set({{24_in, 24_in, 0_deg}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

p_imovement united_odom, expecting {{0_in, 0_in, 0_deg}, ez::fwd, 110} 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.pid_odom_boomerang_set({{24_in, 24_in, 0_deg}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_turn_set()

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

p_itarget {x, y} a target point to face. this uses 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}, ez::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 to face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses 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}, ez::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 to face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses 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 ez::ccw, ez::cw, ez::shortest, ez::longest, ez::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}, ez::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 to face a point using PID and odometry.

p_itarget {x, y} a target point to face. this uses 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 ez::ccw, ez::cw, ez::shortest, ez::longest, ez::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}, ez::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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::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 Units

pid_odom_set()

Sets the robot to go forward/backward the distance you give it, but it uses odometry, using slew only if it is enabled globally.

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.pid_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.pid_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, using slew only if it is enabled globally. If the point has an angle this runs boomerang, otherwise it runs injected pure pursuit. This is a wrapper for pid_odom_boomerang_set() and pid_odom_injected_pp_set().

imovement odom, expecting {{0, 0}, ez::fwd, 110}

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.pid_odom_set({{24, 24}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_set()

Go to an xy coordinate. If the point has an angle this runs boomerang, otherwise it runs injected pure pursuit. This is a wrapper for pid_odom_boomerang_set() and pid_odom_injected_pp_set().

imovement odom, expecting {{0, 0}, ez::fwd, 110} 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.pid_odom_set({{24, 24}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_set()

Create and smooth out a path from the given points, using slew only if it is enabled globally. The path will switch to boomerang if an angle is specified for that point. This is a wrapper for pid_odom_smooth_pp_set.

imovements vector of odom

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}, ez::fwd, 110},
                      {{24, 24}, ez::fwd, 110}});
chassis.pid_wait();
}

pid_odom_set()

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

imovements vector of odom 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}, ez::fwd, 110},
                      {{24, 24}, ez::fwd, 110}},
                     true);
chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate, using slew only if it is enabled globally.

imovement odom, expecting {{0, 0}, ez::fwd, 110}

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}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_ptp_set()

Go to an xy coordinate with slew.

imovement odom, expecting {{0, 0}, ez::fwd, 110} 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}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given.

imovements vector of odom

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}, ez::fwd, 110},
                           {{24, 24}, ez::fwd, 110}});
  chassis.pid_wait();
}

pid_odom_pp_set()

Pure pursuits through all the points given with slew.

imovements vector of odom
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}, ez::fwd, 110},
                           {{24, 24}, ez::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 odom

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}, ez::fwd, 110},
                                    {{24, 24}, ez::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 odom 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}, ez::fwd, 110},
                                    {{24, 24}, ez::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 odom

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}, ez::fwd, 110},
                                  {{24, 24}, ez::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 odom 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}, ez::fwd, 110},
                                  {{24, 24}, ez::fwd, 110}}, 
                                  true);
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

imovement odom, expecting {{0, 0, 0}, ez::fwd, 110}

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.pid_odom_boomerang_set({{24, 24, 0}, ez::fwd, 110});
  chassis.pid_wait();
}

pid_odom_boomerang_set()

Goes to an xy coordinate at a set heading.

imovement odom, expecting {{0, 0, 0}, ez::fwd, 110} 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.pid_odom_boomerang_set({{24, 24,  0}, ez::fwd, 110}, true);
  chassis.pid_wait();
}

pid_turn_set()

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

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}, ez::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 to face a point using PID and odometry.

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}, ez::fwd, 110, true);
  chassis.pid_wait();
}

Example

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

pid_turn_set()

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

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 ez::ccw, ez::cw, ez::shortest, ez::longest, ez::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}, ez::fwd, 110, ez::longest);
  chassis.pid_wait();
}

Example

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

pid_turn_set()

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

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 ez::ccw, ez::cw, ez::shortest, ez::longest, ez::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}, ez::fwd, 110, ez::longest, true);
  chassis.pid_wait();
}

Example

void pid_turn_set(pose 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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::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}, ez::fwd, 110},
                        {{12_in, 24_in}, ez::rev, 110},
                        {{24_in, 24_in}, ez::rev, 110}},
                       true);
  chassis.pid_wait_until({12, 24});  // Waits until the robot passes 12, 24
  Intake.move(127);
  chassis.pid_wait();
}