Commands

Commands are reusable units of behavior in CoreControl. They encapsulate logic that can be started, executed over time, and stopped. Commands are the primary way to define robot actions, from simple motor movements to complex autonomous sequences.

Overview

A Command is defined by three main lifecycle phases:

1. onStart: Executed once when the command begins.
2. onLoop: Executed repeatedly while the command is active.
3. onStop: Executed once when the command finishes or is interrupted.

A command runs until its shouldStop condition returns true.

Usage

You can create commands by instantiating the Command class or using the lifecycle helper function.

Kotlin

// Using the helper function (Recommended)
val myCommand = lifecycle(
    onStart = { motor.power = 1.0 },
    onLoop = { /* continuous updates */ },
    onStop = { motor.power = 0.0 },
    shouldStop = { sensor.distance < 10.0 }
)

// Registering the command to run
myCommand.register()
// OR simply
myCommand()

Java

// Using the helper function (Recommended)
Command myCommand = lifecycle(
    () -> motor.setPower(1.0), // onStart
    () -> {}, // onLoop
    () -> motor.setPower(0.0), // onStop
    () -> sensor.getDistance() < 10.0 // shouldStop
);

// Registering the command to run
myCommand.register();
// OR simply
myCommand.start();

Basic Commands

InstantCommand

Executes a single action and finishes immediately.

Kotlin

instant { servo.position = 1.0 }

Java

instant(() -> servo.setPosition(1.0));

TimedCommand

Runs for a specified duration.

Kotlin

withTiming(2.0, // seconds
    onStart = { motor.power = 0.5 },
    onStop = { motor.power = 0.0 }
)

Java

withTiming(2.0, // seconds
    () -> motor.setPower(0.5),
    () -> {},
    () -> motor.setPower(0.0)
);

WaitCommand

Does nothing for a specified duration. Useful in sequences.

Kotlin

wait(1.5) // seconds
// OR
wait(1500L) // milliseconds

Java

wait(1.5); // seconds
// OR
wait(1500L); // milliseconds

WaitUntilCommand

Waits until a condition is met.

Kotlin

waitUntil { sensor.isPressed }

Java

waitUntil(() -> sensor.isPressed());

Command Groups

Command groups allow you to combine multiple commands into complex behaviors.

SequentialCommandGroup

Runs commands one after another.

Kotlin

sequentially(
    instant { closeClaw() },
    wait(0.5),
    withTiming(2.0, onStart = { liftUp() })
)

Java

sequentially(
    instant(() -> closeClaw()),
    wait(0.5),
    withTiming(2.0, () -> liftUp())
);

ParallelCommandGroup

Runs commands simultaneously. Finishes when all commands finish.

Kotlin

inParallel(
    withTiming(2.0, onStart = { driveForward() }),
    withTiming(1.0, onStart = { raiseLift() })
)

Java

inParallel(
    withTiming(2.0, () -> driveForward()),
    withTiming(1.0, () -> raiseLift())
);

RacingCommandGroup

Runs commands simultaneously. Finishes when any command finishes (cancelling the others).

Kotlin

racing(
    DriveToTarget(),
    wait(5.0) // Timeout after 5 seconds
)

Java

racing(
    new DriveToTarget(),
    wait(5.0) // Timeout after 5 seconds
);

ConditionalCommandGroup

Runs one of two commands based on a condition checked at runtime.

Kotlin

chooseOne(
    { sensor.hasObject },
    ScoreObject(), // If true
    SearchForObject() // If false
)

// OR

runIf(
    { sensor.isTooClose },
    StopMoving()
)

Java

chooseOne(
    () -> sensor.hasObject(),
    new ScoreObject(), // If true
    new SearchForObject() // If false
);

// OR

runIf(
    () -> sensor.isTooClose(),
    new StopMoving()
);

SelectCommandGroup

Dynamically selects a command to run.

Kotlin

select {
    when (visionResult) {
        LEFT -> GoLeft()
        RIGHT -> GoRight()
        else -> wait(1.0)
    }
}

Java

select(() -> {
    switch (visionResult) {
        case LEFT: return new GoLeft();
        case RIGHT: return new GoRight();
        default: return wait(1.0);
    }
});