PathPlanner Paths

1. Install PathPlanner from the Microsoft Store or the GitHub releases page.
2. Click Open Robot Project and pick the project root, the folder with build.gradle in it. The app creates src/main/deploy/pathplanner.
3. In VS Code, open the WPILib Vendor Dependencies view from the activity bar. Expand INSTALL FROM URL, paste the URL below, and press Install.
4. Build the project. It should compile with nothing else added.

1https://raw.githubusercontent.com/JosephTLockwood/pathplanner/vendordep/PathplannerLib.json

Draw the trip Leave Start made, from the same tape mark. The field in the app has its origin at the blue alliance corner, the same as Drivetrain/Pose.

1. Click + in the Paths section and name the path Leave Start.
2. Drag the first waypoint onto the tape mark. Set Ideal Starting State rotation to the way the front bumper points.
3. Drag the last waypoint about two meters out, in open floor. Set Goal End State rotation to 45 degrees and leave its velocity at 0.
4. Set Global Constraints to 2 m/s and 2 m/s². Watch the bumper outline through the preview, not just the line.

The app saves as you go, to deploy/pathplanner/paths/Leave Start.path. That file ships to the robot with every deploy.

A path on its own does nothing. The robot runs autos, so wrap the path in one. Click + in the Autos section, name it Leave Start, and drag the Leave Start path into its command list. Leave Reset Odometry on. At enable it tells odometry the robot is sitting on the first path's start pose.

The branch ships two longer autos built the same way. Each box in the list runs after the one above it finishes:

Shoot and Leave

Path, action, path

Start to Shoot, then the Shoot named command, then Shoot to Neutral Zone.

Neutral Zone Run

Path, path, action

Start to Neutral Zone, with an Intake zone along it, then Neutral Zone to Shoot and Shoot.

AutoBuilder is what turns a file into a command. It has to know how to read this robot and how to drive it, once, before any auto loads. That goes in the DriveMechanism constructor.

1// Teaches PathPlanner how to drive this robot. After this, AutoBuilder can turn any path or
2// auto drawn in the PathPlanner app into a command.
3AutoBuilder.configure(
4    () -> getPose(), // where the robot is
5    pose -> resetPose(pose), // used when an auto says where the robot starts
6    () -> getRobotVelocity(), // how fast it is moving, in its own directions
7    speeds -> drivetrain.setControl(pathRequest.withVelocity(speeds)), // drive like this
8    // Pulls the robot back onto the path when it drifts. The first gain is for position (m/s
9    // of correction per meter of error), the second for heading. TODO: tune on your robot.
10    new PPHolonomicDriveController(
11        new PIDConstants(5.0, 0.0, 0.0), new PIDConstants(5.0, 0.0, 0.0)),
12    loadPathConfig(),
13    // Paths are drawn from the blue side. On red, PathPlanner mirrors them across the field.
14    () -> MatchState.getAlliance().orElse(Alliance.BLUE) == Alliance.RED,
15    this); // path commands require this mechanism

Import AutoBuilder from com.pathplanner.lib.command3. The one in com.pathplanner.lib.auto makes commands for the other framework, and they will not compile against org.wpilib.command3.Command.

pathRequest is a SwerveRequest.ApplyRobotVelocity field, because PathPlannerLib hands back speeds relative to the robot. loadPathConfig() wraps RobotConfig.fromGUISettings(), which reads the Robot Config tab out of deploy/pathplanner/settings.json.

Delete LeaveStartAuto.java. The drawn auto replaces it, and one @Autonomous class now runs every auto in the project. It registers the named commands, asks AutoBuilder for a drop-down of autos, and runs the selected one at enable.

1@Autonomous(name = "Auto")
2public class AutoOpMode extends PeriodicOpMode {
3  private final Selectable<Command> autoChooser;
4  private Command routine;
5 
6  public AutoOpMode(Robot robot) {
7    // The name in quotes must match the name in the PathPlanner app exactly.
8    NamedCommands.registerCommand(
9        "Shoot",
10        Command.noRequirements(coroutine -> coroutine.wait(Seconds.of(1.0))).named("Shoot"));
11    NamedCommands.registerCommand(
12        "Intake", Command.noRequirements(coroutine -> coroutine.park()).named("Intake"));
13 
14    // PathPlanner fills this with one choice per auto drawn in the app, plus "None". It loads
15    // every auto, so the named commands above have to be registered first.
16    autoChooser = AutoBuilder.buildAutoChooser("Leave Start");
17    Tunables.publish("Auto", autoChooser);
18  }
19 
20  @Override
21  public void start() {
22    routine = autoChooser.getSelected();
23    Scheduler.getDefault().schedule(routine);
24  }
25 
26  @Override
27  public void end() {
28    Scheduler.getDefault().cancel(routine);
29  }
30 
31  /** Takes the drop-down off the dashboard when another OpMode is picked. */
32  @Override
33  public void close() {
34    Tunables.remove("Auto");
35  }
36}

Does nothing

A missing name

The driver station reports a missing file, or the auto skips an action. A name in the app does not match a path file or a registered command, letter for letter.

Wrong place

Pose and plan disagree

The robot drives the right shape, offset or rotated. The starting rotation in the app does not match the way the robot sat on the tape.

Lags or overshoots

Config or gains

The robot falls behind the path or swings past its end. A guessed top speed or mass asks for more than the robot has. Fix the config before the gains.

1. Run WPILib: Simulate Robot Code. Pick Auto from the autonomous list. In the sim GUI, open NetworkTables and check that Tunables/Auto/options lists all three autos and None.
2. Enable with Leave Start selected. Watch Drivetrain/Pose on the 2D field in AdvantageScope.
3. Select Neutral Zone Run, enable again, and watch the scheduler for Intake and Shoot.
4. Deploy, put the robot on the tape mark, and run Leave Start three times with one person on disable.