Lab 7: Timed Autonomous on the WCD#

Why it matters#

The first 15 seconds of every FRC match are autonomous: the robot runs entirely on its own code, with no driver input. A robot that does something useful in auto starts every match ahead.

In this lab you'll make the West Coast Drive drive a pattern by itself, and let the drive team pick which pattern from a menu on the dashboard. You'll use only time to decide how far to go, and you'll find out why that's not good enough. That sets up Lab 8, where the robot uses a gyro to know how far it has really turned.

Before you start: finish Lab 2. You'll add to the same WestCoastDrive project. Lesson 11 covers autonomous in more depth.

Read this#

• Command Compositions
• Lesson 6.1: A dropdown menu with Selectable

Walkthrough#

How autonomous runs#

You don't have to write any of this, but you should know it's there. In Robot.java, the template already does:

1. When auto starts, autonomousInit() asks RobotContainer.getAutonomousCommand() for a command and schedules it.
2. The scheduler runs it every 20 ms until it ends.
3. When teleop starts, teleopInit() cancels it, in case it's still running.

So your whole job is to make getAutonomousCommand() return the right command. While an auto command is using the drivetrain, the joystick default command pauses, then comes back when auto ends.

Step 1: A command that drives for a set time#

Open DriveSubsystem.java and add:

  /** Drives each side at a fixed speed for a set time, then stops. */
  public Command driveForSecondsCommand(double leftSpeed, double rightSpeed, double seconds) {
    return run(() -> m_drive.tankDrive(leftSpeed, rightSpeed, false))  // false = don't square
        .withTimeout(seconds)
        .finallyDo(() -> m_drive.stopMotor())
        .withName("Drive " + seconds + " s");
  }

With this one command you can drive forward (both sides the same), backward (both negative), or spin in place (sides opposite). Remember the skid steer levers from Lab 2.

Step 2: Build routines from pieces#

Routines are just commands chained together. Add these methods to RobotContainer.java:

  /** Drive straight forward for 2 seconds. */
  private Command driveForwardAuto() {
    return m_driveSubsystem.driveForSecondsCommand(0.4, 0.4, 2.0)
        .withName("Drive Forward");
  }

  /** One side of a square: drive forward, pause, spin left about 90 degrees, pause. */
  private Command squareSide() {
    return Commands.sequence(
        m_driveSubsystem.driveForSecondsCommand(0.4, 0.4, 1.0),    // forward
        m_driveSubsystem.driveForSecondsCommand(0.0, 0.0, 0.3),    // pause
        m_driveSubsystem.driveForSecondsCommand(-0.4, 0.4, 0.5),   // spin left (guess the time!)
        m_driveSubsystem.driveForSecondsCommand(0.0, 0.0, 0.3));   // pause
  }

  /** Try to drive a square and end where it started. */
  private Command squareAuto() {
    return Commands.sequence(squareSide(), squareSide(), squareSide(), squareSide())
        .withName("Square");
  }

Import edu.wpi.first.wpilibj2.command.Commands.

Piece by piece:

Step 3: Let the drive team pick#

A Selectable puts a dropdown menu in Elastic, sent over NetworkTables like everything else. It's part of the course's telemetry folder you copied in Lab 2, and it's the same as WPILib 2027's Selectable (Lesson 6.1).

Add a field to RobotContainer:

  private final Selectable<Command> m_autoChooser = new Selectable<>();

In the constructor, after configureBindings(), add the options and put the menu on the dashboard:

    m_autoChooser.addDefault("Do nothing", Commands.none());
    m_autoChooser.add("Drive forward", driveForwardAuto());
    m_autoChooser.add("Square", squareAuto());
    Tunables.publish("Auto", m_autoChooser);   // shows up as /Tunables/Auto

And make getAutonomousCommand() return the choice:

  public Command getAutonomousCommand() {
    return m_autoChooser.getSelected();
  }

Import frc.robot.telemetry.Selectable and frc.robot.telemetry.Tunables.

Step 4: Run it#

1. Deploy. In Elastic, find Tunables → Auto, drag it onto your tab (it shows up as a ComboBox Chooser), and pick Drive forward.
2. On blocks first: in the Driver Station, select Autonomous, say "Enabling!", and enable. The wheels run for 2 seconds and stop.
3. On the floor: put tape on the floor at the robot's front edge, and run it again. Mark where it stops.
4. Run Square on blocks, then on the floor. Adjust the spin time in squareSide() until it looks close to a square.

Step 5: How repeatable is it?#

Run Square five times without changing anything. Each time, measure how far the robot ends up from where it started.

Then swap in a less charged battery and run it twice more.

What you'll see: The square doesn't close, and it's different every time. Turns that were 90° become 80° or 100°, and the errors add up corner by corner. A weaker battery makes every move shorter.

The problem is the same one from Lab 6's timed attempt: the robot doesn't measure how far it turned. It only knows how long it tried. In Lab 8 you'll add a gyro so it does.

Step 6: Commit#

git add .
git commit -m "Lab 7: timed autonomous"

Try it#

• Run Drive forward and Square from the chooser
• Tune the spin time until a single turn is close to 90°
• Fill in the repeatability table, including the less charged battery
• Add a Drive backward option to the chooser
• Write a "there and back" routine: forward 1.5 seconds, spin 180°, forward 1.5 seconds. Does it end where it started?
• Make the spin a gentle curve instead of turning in place (hint: both sides forward, one faster)

Check yourself#