Autonomous Basics

The basics of autonomous with WPILib.

Command Groups

Command groups are simple way to pair multiple commands together to create an autonomous routine.

Sequential Command Group

The most popular of the command groups, SequentialCommandGroup will run a list of commands in sequential order. Starting with the first command in the list then the second and so on.

Warning

The SequentialCommandGroup will not finish unless all the commands finish. Also if a command in the list does not finish the next command in line will not start.

JavaC++

import edu.wpi.first.wpilibj2.command.SequentialCommandGroup;

public class Example extends SequentialCommandGroup
{
    public Example()
    {
        addCommands
        (
            //Drive Forward
            new DriveForward(),

            //Drive Reverse
            new DriveReverse()
        );
    }
}

In the above example using SequentialCommandGroup the command DriveForward() will be executed first and when complete the command DriveReverse() will be executed.

Caution

If DriveForward() does not end DriveReverse() will never start.

Parallel Command Group

The ParallelCommandGroup is just like the SequentialCommandGroup except that all the commands run at the same time. The command group will only finish when all commands are finished.

JavaC++

import edu.wpi.first.wpilibj2.command.ParallelCommandGroup;

public class Example extends ParallelCommandGroup
{
    public Example()
    {
        addCommands
        (
            //Drive Forward
            new DriveForward(),

            //Move Arm to Home Position
            new Arm(Pos.Home)
        );
    }
}

In the above example using ParallelCommandGroup the commands DriveForward() and Arm(Pos.Home) will be executed at the same time.

Caution

Both DriveForward() and Arm(Pos.Home) MUST complete to move on. If they do not complete the routine will be stuck at the example() call.

Parallel Race Group

The ParallelRaceGroup is similar to the ParallelCommandGroup except that a race condition is created. All commands start at the same time but, when one command is finished it interrupts all other commands running and ends the command group.

JavaC++

import edu.wpi.first.wpilibj2.command.ParallelRaceGroup;

public class Example extends ParallelRaceGroup
{
    public Example()
    {
        addCommands
        (
            //Drive Forward
            new DriveForward(),

            //Move Arm to Home Position
            new Arm(Pos.Home)
        );
    }
}

In the above example using ParallelRaceGroup the commands DriveForward() and Arm(Pos.Home) will be executed at the same time.

Note

If DriveForward() or Arm(Pos.Home) completes before the other then the other will be interrupted and stop running.

Java Only Benefits

For Java only, Static Factory Methods are possible, allowing a much simplar way to declare command groups.

sequence()

The sequence() static method allows for a sequential command group.

parallel()

The parallel() static method allows for a parallel command group.

race()

The race() static method allows for a parallel race group.

Java

import edu.wpi.first.wpilibj2.command.SequentialCommandGroup;

public class Example extends SequentialCommandGroup
{
    public Example()
    {
        addCommands
        (
            race(new DriveForward(), new ElevatorUP()),
            parallel(new ShootObject(), new LineupGoal()),
            sequence(new DriveReverse(), new StrafeRight())
        );
    }
}

If we analyze this command group we can break down what is happening.

1. We have race(new DriveForward(), new ElevatorUP()) this will create a ParallelRaceGroup that has the two commands DriveForward() and ElevatorUP() run at the same time in a race. When one finishes it will stop the other.

2. As the main command group is the SequentialCommandGroup we then move on to the next command which is a ParallelCommandGroup.

3. The ParallelCommandGroup of parallel(new ShootObject(), new LineupGoal()) tells us that ShootObject() and LineupGoal() happen at the same time. When both are complete it will pass to the next command group.

4. The last command group here is the sequence(new DriveReverse(), new StrafeRight()) which is also a SequentialCommandGroup. This group is telling the robot to DriveReverse() and when that is done to StrafeRight().

Conditional Command

The ConditionalCommand will run one command or another based on condition that must be met.

JavaC++

// Base parameters
new ConditionalCommand(trueCommand, falseCommand, boolean condition);

// Use case
new ConditionalCommand(new DriveForward(), new DriveReverse(), isLimitHit());

Wait Command

The WaitCommand() is useful for when a timed wait period is required.

JavaC++

// Waits 10 seconds
new WaitCommand(10);

Wait Until Command

The WaitUntilCommand is an upgraded version of WaitCommand() as a boolean condition can be added.

JavaC++

// Waits 10 seconds
new WaitUntilCommand(10);

// Waits for limit switch to be true
new WaitUntilCommand(isLimitHit());

Command Decorators

Command decorators take the base command and add additonal functionalities to it.

withTimeout()

Adds a timeout to the command. When the timeout expires the command will be interrupted and end.

JavaC++

// Add a 10 second timeout
new command.withTimeout(10);

withInterrupt()

Adds a condition that will interrupt the command.

JavaC++

new command.withInterrupt(isLimitHit());

andThen()

Adds a method that is executed after the command ends.

JavaC++

new command.andThen(() -> System.out.println("Command Finished"););

beforeStarting()

Adds a method that is executed before the command starts.

JavaC++

new command.beforeStarting(() -> System.out.println("Command Starting"););