Package edu.wpi.first.wpilibj2.command

Class Command

java.lang.Object
edu.wpi.first.wpilibj2.command.Command
All Implemented Interfaces:
Sendable
Direct Known Subclasses:
CommandBase, ConditionalCommand, DeferredCommand, FunctionalCommand, MecanumControllerCommand, NotifierCommand, ParallelCommandGroup, ParallelDeadlineGroup, ParallelRaceGroup, PIDCommand, ProfiledPIDCommand, ProxyCommand, RamseteCommand, RepeatCommand, ScheduleCommand, SelectCommand, SequentialCommandGroup, SwerveControllerCommand, TrapezoidProfileCommand, WaitCommand, WaitUntilCommand, WrapperCommand
public abstract class Command
extends Object
implements Sendable
A state machine representing a complete action to be performed by the robot. Commands are run by the CommandScheduler, and can be composed into CommandGroups to allow users to build complicated multistep actions without the need to roll the state machine logic themselves.

Commands are run synchronously from the main robot loop; no multithreading is used, unless specified explicitly from the command implementation.

This class is provided by the NewCommands VendorDep

  • Field Details

  • Constructor Details

  • Method Details

    • initialize

      public void initialize()
      The initial subroutine of a command. Called once when the command is initially scheduled.

    • execute

      public void execute()
      The main body of a command. Called repeatedly while the command is scheduled.

    • end

      public void end​(boolean interrupted)
      The action to take when the command ends. Called when either the command finishes normally, or when it interrupted/canceled.

      Do not schedule commands here that share requirements with this command. Use andThen(Command...) instead.

      Parameters:
      interrupted - whether the command was interrupted/canceled

    • isFinished

      public boolean isFinished()
      Whether the command has finished. Once a command finishes, the scheduler will call its end() method and un-schedule it.
      Returns:
      whether the command has finished.

    • getRequirements

      public Set<Subsystem> getRequirements()
      Specifies the set of subsystems used by this command. Two commands cannot use the same subsystem at the same time. If another command is scheduled that shares a requirement, getInterruptionBehavior() will be checked and followed. If no subsystems are required, return an empty set.

      Note: it is recommended that user implementations contain the requirements as a field, and return that field here, rather than allocating a new set every time this is called.

      Returns:
      the set of subsystems that are required
      See Also:
      Command.InterruptionBehavior

    • addRequirements

      public final void addRequirements​(Subsystem... requirements)
      Adds the specified subsystems to the requirements of the command. The scheduler will prevent two commands that require the same subsystem from being scheduled simultaneously.

      Note that the scheduler determines the requirements of a command when it is scheduled, so this method should normally be called from the command's constructor.

      Parameters:
      requirements - the requirements to add

    • getName

      public String getName()
      Gets the name of this Command.

      By default, the simple class name is used. This can be changed with setName(String).

      Returns:
      The display name of the Command

    • setName

      public void setName​(String name)
      Sets the name of this Command.
      Parameters:
      name - The display name of the Command.

    • getSubsystem

      public String getSubsystem()
      Gets the subsystem name of this Command.
      Returns:
      Subsystem name

    • setSubsystem

      public void setSubsystem​(String subsystem)
      Sets the subsystem name of this Command.
      Parameters:
      subsystem - subsystem name

    • withTimeout

      public ParallelRaceGroup withTimeout​(double seconds)
      Decorates this command with a timeout. If the specified timeout is exceeded before the command finishes normally, the command will be interrupted and un-scheduled.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      seconds - the timeout duration
      Returns:
      the command with the timeout added

    • until

      public ParallelRaceGroup until​(BooleanSupplier condition)
      Decorates this command with an interrupt condition. If the specified condition becomes true before the command finishes normally, the command will be interrupted and un-scheduled.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      condition - the interrupt condition
      Returns:
      the command with the interrupt condition added
      See Also:
      onlyWhile(BooleanSupplier)

    • onlyWhile

      public ParallelRaceGroup onlyWhile​(BooleanSupplier condition)
      Decorates this command with a run condition. If the specified condition becomes false before the command finishes normally, the command will be interrupted and un-scheduled.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      condition - the run condition
      Returns:
      the command with the run condition added
      See Also:
      until(BooleanSupplier)

    • beforeStarting

      public SequentialCommandGroup beforeStarting​(Runnable toRun, Subsystem... requirements)
      Decorates this command with a runnable to run before this command starts.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      toRun - the Runnable to run
      requirements - the required subsystems
      Returns:
      the decorated command

    • beforeStarting

      public SequentialCommandGroup beforeStarting​(Command before)
      Decorates this command with another command to run before this command starts.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      before - the command to run before this one
      Returns:
      the decorated command

    • andThen

      public SequentialCommandGroup andThen​(Runnable toRun, Subsystem... requirements)
      Decorates this command with a runnable to run after the command finishes.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      toRun - the Runnable to run
      requirements - the required subsystems
      Returns:
      the decorated command

    • andThen

      public SequentialCommandGroup andThen​(Command... next)
      Decorates this command with a set of commands to run after it in sequence. Often more convenient/less-verbose than constructing a new SequentialCommandGroup explicitly.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      next - the commands to run next
      Returns:
      the decorated command

    • deadlineWith

      public ParallelDeadlineGroup deadlineWith​(Command... parallel)
      Decorates this command with a set of commands to run parallel to it, ending when the calling command ends and interrupting all the others. Often more convenient/less-verbose than constructing a new ParallelDeadlineGroup explicitly.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      parallel - the commands to run in parallel
      Returns:
      the decorated command

    • alongWith

      public ParallelCommandGroup alongWith​(Command... parallel)
      Decorates this command with a set of commands to run parallel to it, ending when the last command ends. Often more convenient/less-verbose than constructing a new ParallelCommandGroup explicitly.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      parallel - the commands to run in parallel
      Returns:
      the decorated command

    • raceWith

      public ParallelRaceGroup raceWith​(Command... parallel)
      Decorates this command with a set of commands to run parallel to it, ending when the first command ends. Often more convenient/less-verbose than constructing a new ParallelRaceGroup explicitly.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      parallel - the commands to run in parallel
      Returns:
      the decorated command

    • repeatedly

      public RepeatCommand repeatedly()
      Decorates this command to run repeatedly, restarting it when it ends, until this command is interrupted. The decorated command can still be canceled.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Returns:
      the decorated command

    • asProxy

      public ProxyCommand asProxy()
      Decorates this command to run "by proxy" by wrapping it in a ProxyCommand. This is useful for "forking off" from command compositions when the user does not wish to extend the command's requirements to the entire command composition.
      Returns:
      the decorated command

    • unless

      public ConditionalCommand unless​(BooleanSupplier condition)
      Decorates this command to only run if this condition is not met. If the command is already running and the condition changes to true, the command will not stop running. The requirements of this command will be kept for the new conditional command.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      condition - the condition that will prevent the command from running
      Returns:
      the decorated command
      See Also:
      onlyIf(BooleanSupplier)

    • onlyIf

      public ConditionalCommand onlyIf​(BooleanSupplier condition)
      Decorates this command to only run if this condition is met. If the command is already running and the condition changes to false, the command will not stop running. The requirements of this command will be kept for the new conditional command.

      Note: This decorator works by adding this command to a composition. The command the decorator was called on cannot be scheduled independently or be added to a different composition (namely, decorators), unless it is manually cleared from the list of composed commands with CommandScheduler.removeComposedCommand(Command). The command composition returned from this method can be further decorated without issue.

      Parameters:
      condition - the condition that will allow the command to run
      Returns:
      the decorated command
      See Also:
      unless(BooleanSupplier)

    • ignoringDisable

      public WrapperCommand ignoringDisable​(boolean doesRunWhenDisabled)
      Decorates this command to run or stop when disabled.
      Parameters:
      doesRunWhenDisabled - true to run when disabled.
      Returns:
      the decorated command

    • withInterruptBehavior

      public WrapperCommand withInterruptBehavior​(Command.InterruptionBehavior interruptBehavior)
      Decorates this command to have a different interruption behavior.
      Parameters:
      interruptBehavior - the desired interrupt behavior
      Returns:
      the decorated command

    • finallyDo

      public WrapperCommand finallyDo​(BooleanConsumer end)
      Decorates this command with a lambda to call on interrupt or end, following the command's inherent end(boolean) method.
      Parameters:
      end - a lambda accepting a boolean parameter specifying whether the command was interrupted.
      Returns:
      the decorated command

    • finallyDo

      public WrapperCommand finallyDo​(Runnable end)
      Decorates this command with a lambda to call on interrupt or end, following the command's inherent end(boolean) method. The provided lambda will run identically in both interrupt and end cases.
      Parameters:
      end - a lambda to run when the command ends, whether or not it was interrupted.
      Returns:
      the decorated command

    • handleInterrupt

      public WrapperCommand handleInterrupt​(Runnable handler)
      Decorates this command with a lambda to call on interrupt, following the command's inherent end(boolean) method.
      Parameters:
      handler - a lambda to run when the command is interrupted
      Returns:
      the decorated command

    • schedule

      public void schedule()
      Schedules this command.

    • cancel

      public void cancel()
      Cancels this command. Will call end(true). Commands will be canceled regardless of interruption behavior.
      See Also:
      CommandScheduler.cancel(Command...)

    • isScheduled

      public boolean isScheduled()
      Whether the command is currently scheduled. Note that this does not detect whether the command is in a composition, only whether it is directly being run by the scheduler.
      Returns:
      Whether the command is scheduled.

    • hasRequirement

      public boolean hasRequirement​(Subsystem requirement)
      Whether the command requires a given subsystem.
      Parameters:
      requirement - the subsystem to inquire about
      Returns:
      whether the subsystem is required

    • getInterruptionBehavior

      public Command.InterruptionBehavior getInterruptionBehavior()
      How the command behaves when another command with a shared requirement is scheduled.
      Returns:
      a variant of Command.InterruptionBehavior, defaulting to kCancelSelf.

    • runsWhenDisabled

      public boolean runsWhenDisabled()
      Whether the given command should run when the robot is disabled. Override to return true if the command should run when disabled.
      Returns:
      whether the command should run when the robot is disabled

    • withName

      public WrapperCommand withName​(String name)
      Decorates this Command with a name.
      Parameters:
      name - name
      Returns:
      the decorated Command

    • initSendable

      public void initSendable​(SendableBuilder builder)
      Description copied from interface: Sendable
      Initializes this Sendable object.
      Specified by:
      initSendable in interface Sendable
      Parameters:
      builder - sendable builder