Distance Sensor
Auton Correction

The Core Pattern

Every wall reset follows the same three-step sequence:

Where to Place Resets in a Route

What the Sensor Actually Measures

The V5 distance sensor fires a Class 1 laser pulse and measures time-of-flight. It returns a value in millimeters. At competition distances (100–800mm from wall), it's accurate to ±5mm consistently — more than precise enough for wall correction.

Placement Rules

Recommended Positions

1. Declare the Sensor

In your globals.cpp or at the top of main.cpp:

// Distance sensor on Smart Port 10
pros::Distance side_dist(10);   // Side-facing, for X correction
pros::Distance front_dist(11);  // Front-facing, for Y correction (optional)

2. Wall Reset Function

Write a reusable function that drives to the wall and stops at a target distance:

// Drive toward the right wall until 200mm from it, then stop
void reset_to_right_wall(int target_mm = 200) {
  chassis.drive_speed(-30);   // Negative = strafe right (holonomic) or adjust for your drive
  while (side_dist.get() > target_mm) {
    pros::delay(10);          // Poll every 10ms
  }
  chassis.drive_speed(0);
  pros::delay(100);           // Settle time before reading

  // Reset odometry X coordinate
  // If robot edge to wall is 200mm, robot center X = 200mm + half_robot_width
  double corrected_x = target_mm + 9.0; // 9 inches = half of 18" robot
  chassis.odom_set_pose({corrected_x / 25.4, chassis.odom_pose_get().y,
                          chassis.odom_pose_get().theta});
}

3. Simpler Pattern — Stop and Check

If you just want to stop at the wall without odometry reset:

// Drive forward until 150mm from front wall
chassis.set_max_speed(25);
chassis.drive_distance(48);    // Drive up to 48 inches

// Override — stop early if sensor triggers
while (!chassis.drive_settled()) {
  if (front_dist.get() < 150) {
    chassis.drive_speed(0);
    break;
  }
  pros::delay(10);
}
chassis.set_max_speed(127);    // Restore speed

4. Mid-Route Reset Pattern

Use this between scoring actions to correct drift mid-route:

void auton_route() {
  // Phase 1 — score first element
  chassis.drive_distance(24);
  chassis.turn_angle(90);
  // ... scoring code ...

  // Wall reset checkpoint — correct X before phase 2
  reset_to_right_wall(200);

  // Phase 2 — now navigating from corrected position
  chassis.drive_distance(36);
  chassis.turn_angle(-45);
  // ... scoring code ...
}

// Averaged reading for more stable reset
int avg_distance() {
  int total = 0;
  for (int i = 0; i < 5; i++) {
    total += side_dist.get();
    pros::delay(10);
  }
  return total / 5;
}

This example shows a Push Back-style auton that uses two wall resets — one at the start and one mid-route. Adapt the distances and actions to your actual robot and route.

// In globals.cpp
pros::Distance side_dist(10);

// Utility: averaged distance reading
int read_dist_avg(pros::Distance& sensor, int samples = 5) {
  int total = 0;
  for (int i = 0; i < samples; i++) {
    total += sensor.get();
    pros::delay(10);
  }
  return total / samples;
}

// Wall reset utility
void reset_x_from_right_wall(double target_mm = 200) {
  // Slowly strafe toward wall
  chassis.set_max_speed(25);
  chassis.strafe_distance(-12);  // Move right up to 12 inches

  while (!chassis.drive_settled()) {
    if (side_dist.get() < (int)target_mm) {
      chassis.drive_speed(0);
      break;
    }
    pros::delay(10);
  }
  pros::delay(150);  // Settle

  // Average the reading for accuracy
  int actual_mm = read_dist_avg(side_dist);

  // Convert mm to inches, add half robot width (9 in for 18" robot)
  double robot_center_x = (actual_mm / 25.4) + 9.0;

  // Reset odometry X only — keep Y and heading
  auto pose = chassis.odom_pose_get();
  chassis.odom_set_pose({robot_center_x, pose.y, pose.theta});

  chassis.set_max_speed(127);  // Restore
}

// ── Main Autonomous ──────────────────────────────────────────────
void autonomous() {
  // === RESET 1: Correct starting position ========================
  reset_x_from_right_wall(200);

  // === PHASE 1: Score first goal ================================
  chassis.drive_distance(24);        // Drive forward 24 in
  chassis.turn_angle(45);            // Turn toward goal
  chassis.drive_distance(12);        // Approach goal
  // ... scoring action ...
  chassis.drive_distance(-12);       // Back up

  // === RESET 2: Mid-route correction ============================
  chassis.turn_angle(-45);           // Face the wall
  reset_x_from_right_wall(200);      // Re-correct X

  // === PHASE 2: Score second goal ===============================
  chassis.turn_angle(90);            // Face second goal
  chassis.drive_distance(36);
  // ... scoring action ...
}

Debugging Checklist

Role Connections

Judge Interview Questions