Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| " 2013 FRC Java API "
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.wpi.first.wpilibj.command
Class CommandGroup

    java.lang.Object
      edu.wpi.first.wpilibj.command.Command
          edu.wpi.first.wpilibj.command.CommandGroup

All Implemented Interfaces:
  NamedSendable, Sendable

    public class CommandGroup

extends Command

A `CommandGroup` is a list of commands which are executed in sequence.

Commands in a `CommandGroup` are added using the `addSequential(...)` method and are called sequentially. `CommandGroups` are themselves `commands` and can be given to other `CommandGroups`.

`CommandGroups` will carry all of the requirements of their `subcommands`. Additional requirements can be specified by calling `requires(...)` normally in the constructor.

CommandGroups can also execute commands in parallel, simply by adding them using `addParallel(...)`.

Author:
  Brad Miller, Joe Grinstead
See Also:
  `Command`, `Subsystem`, `IllegalUseOfCommandException`

Constructor Summary
`CommandGroup()` Creates a new `CommandGroup`.
`CommandGroup(String name)` Creates a new `CommandGroup` with the given name.

Method Summary
`void` | `addParallel(Command command)` Adds a new child `Command` to the group.
`void` | `addParallel(Command command, double timeout)` Adds a new child `Command` to the group with the given timeout.
`void` | `addSequential(Command command)` Adds a new `Command` to the group.
`void` | `addSequential(Command command, double timeout)` Adds a new `Command` to the group with a given timeout.
`protected void` | `end()` Called when the command ended peacefully.
`protected void` | `execute()` The execute method is called repeatedly until this Command either finishes or is canceled.
`protected void` | `initialize()` The initialize method is called the first time this Command is run after being started.
`protected void` | `interrupted()` Called when the command ends because somebody called `cancel()` or another command shared the same requirements as this one, and booted it out.
`protected boolean` | `isFinished()` Returns true if all the `Commands` in this group have been started and have finished.
`boolean` | `isInterruptible()` Returns whether or not this group is interruptible.

Methods inherited from class edu.wpi.first.wpilibj.command.Command
`cancel, doesRequire, getGroup, getName, getSmartDashboardType, getTable, initTable, isCanceled, isRunning, isTimedOut, requires, setInterruptible, setRunWhenDisabled, setTimeout, start, timeSinceInitialized, toString, willRunWhenDisabled`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### CommandGroup

    public CommandGroup()

  Creates a new `CommandGroup`. The name of this command will be set to its class name.

### CommandGroup

    public CommandGroup(String name)

  Creates a new `CommandGroup` with the given name.

  Parameters:
    `name` - the name for this command group
  Throws:
    `IllegalArgumentException` - if name is null

Method Detail

### addSequential

    public final void addSequential(Command command)

  Adds a new `Command` to the group. The `Command` will be started after all the previously added `Commands`.

  Note that any requirements the given `Command` has will be added to the group. For this reason, a `Command's` requirements can not be changed after being added to a group.

  It is recommended that this method be called in the constructor.

  Parameters:
    `command` - The `Command` to be added
  Throws:
    `IllegalUseOfCommandException` - if the group has been started before or been given to another group
    `IllegalArgumentException` - if command is null

### addSequential

    public final void addSequential(Command command,
                                    double timeout)

  Adds a new `Command` to the group with a given timeout. The `Command` will be started after all the previously added commands.

  Once the `Command` is started, it will be run until it finishes or the time expires, whichever is sooner. Note that the given `Command` will have no knowledge that it is on a timer.

  Note that any requirements the given `Command` has will be added to the group. For this reason, a `Command's` requirements can not be changed after being added to a group.

  It is recommended that this method be called in the constructor.

  Parameters:
    `command` - The `Command` to be added
    `timeout` - The timeout (in seconds)
  Throws:
    `IllegalUseOfCommandException` - if the group has been started before or been given to another group or if the `Command` has been started before or been given to another group
    `IllegalArgumentException` - if command is null or timeout is negative

### addParallel

    public final void addParallel(Command command)

  Adds a new child `Command` to the group. The `Command` will be started after all the previously added `Commands`.

  Instead of waiting for the child to finish, a `CommandGroup` will have it run at the same time as the subsequent `Commands`. The child will run until either it finishes, a new child with conflicting requirements is started, or the main sequence runs a `Command` with conflicting requirements. In the latter two cases, the child will be canceled even if it says it can't be interrupted.

  Note that any requirements the given `Command` has will be added to the group. For this reason, a `Command's` requirements can not be changed after being added to a group.

  It is recommended that this method be called in the constructor.

  Parameters:
    `command` - The command to be added
  Throws:
    `IllegalUseOfCommandException` - if the group has been started before or been given to another command group
    `IllegalArgumentException` - if command is null

### addParallel

    public final void addParallel(Command command,
                                  double timeout)

  Adds a new child `Command` to the group with the given timeout. The `Command` will be started after all the previously added `Commands`.

  Once the `Command` is started, it will run until it finishes, is interrupted, or the time expires, whichever is sooner. Note that the given `Command` will have no knowledge that it is on a timer.

  Instead of waiting for the child to finish, a `CommandGroup` will have it run at the same time as the subsequent `Commands`. The child will run until either it finishes, the timeout expires, a new child with conflicting requirements is started, or the main sequence runs a `Command` with conflicting requirements. In the latter two cases, the child will be canceled even if it says it can't be interrupted.

  Note that any requirements the given `Command` has will be added to the group. For this reason, a `Command's` requirements can not be changed after being added to a group.

  It is recommended that this method be called in the constructor.

  Parameters:
    `command` - The command to be added
    `timeout` - The timeout (in seconds)
  Throws:
    `IllegalUseOfCommandException` - if the group has been started before or been given to another command group
    `IllegalArgumentException` - if command is null

### isFinished

    protected boolean isFinished()

  Returns true if all the `Commands` in this group have been started and have finished.

  Teams may override this method, although they should probably reference super.isFinished() if they do.

  Specified by:
    `isFinished` in class `Command`
  Returns:
    whether this `CommandGroup` is finished
  See Also:
    `isTimedOut()`

### initialize

    protected void initialize()

  Description copied from class: `Command`
  The initialize method is called the first time this Command is run after being started.

  Specified by:
    `initialize` in class `Command`

### execute

    protected void execute()

  Description copied from class: `Command`
  The execute method is called repeatedly until this Command either finishes or is canceled.

  Specified by:
    `execute` in class `Command`

### end

    protected void end()

  Description copied from class: `Command`
  Called when the command ended peacefully. This is where you may want to wrap up loose ends, like shutting off a motor that was being used in the command.

  Specified by:
    `end` in class `Command`

### interrupted

    protected void interrupted()

  Description copied from class: `Command`
  Called when the command ends because somebody called `cancel()` or another command shared the same requirements as this one, and booted it out.

  This is where you may want to wrap up loose ends, like shutting off a motor that was being used in the command.

  Generally, it is useful to simply call the `end()` method within this method

  Specified by:
    `interrupted` in class `Command`

### isInterruptible

    public boolean isInterruptible()

  Returns whether or not this group is interruptible. A command group will be uninterruptible if `setInterruptable(false)` was called or if it is currently running an uninterruptible command or child.

  Overrides:
    `isInterruptible` in class `Command`
  Returns:
    whether or not this `CommandGroup` is interruptible.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| " 2013 FRC Java API "
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

"
For updated information see the Java FRC site
"