GamepadEx toolOp = new GamepadEx(gamepad2);
toolOp.getGamepadButton(GamepadKeys.Button.A)
    .whenPressed(new InstantCommand(() -> {
        // phần triển khai run() của bạn tại đây
    }));

Motor intakeMotor = new Motor(hardwareMap, "intake");
toolOp.getGamepadButton(GamepadKeys.Button.RIGHT_BUMPER)
    .whileHeld(new InstantCommand(() -> {
        intakeMotor.set(0.75);
    }))
    .whenReleased(new InstantCommand(intakeMotor::stopMotor));

/**
 * Đây là một intake subsystem mang tính sư phạm
 * cho một intake phổ dụng gồm một motor
 * điều khiển dây đai nối với một puly
 * dẫn động một ống PVC.
 */
public class Intake extends SubsystemBase {
    private Motor m_intakeMotor;
    
    public Intake(Motor intakeMotor) {
        m_intakeMotor = intakeMotor;
    }
    
    public void run() {
        m_intakeMotor.set(0.75);
    }
    
    public void stop() {
        m_intakeMotor.stopMotor();
    }
}

/* trong opmode của bạn */
Motor intakeMotor = new Motor(hardwareMap, "intake");
Intake intake = new Intake(intakeMotor);
toolOp.getGamepadButton(GamepadKeys.Button.RIGHT_BUMPER)
    // tham số thứ hai là varargs của các subsystem
    // cần được yêu cầu (require)
    .whileHeld(new InstantCommand(intake::run, intake))
    .whenReleased(new InstantCommand(intake::stop, intake));

/* trong opmode của bạn */
Motor intakeMotor = new Motor(hardwareMap, "intake");
Intake intake = new Intake(intakeMotor);
toolOp.getGamepadButton(GamepadKeys.Button.RIGHT_BUMPER)
    // tham số thứ hai là varargs của các subsystem
    // cần được yêu cầu
    .whileHeld(new RunCommand(intake::run, intake))
    .whenReleased(new InstantCommand(intake::stop, intake));
    
// giả sử ta có một drive subsystem
// với một phương thức drive
schedule(new RunCommand(driveSubsystem::drive, driveSubsystem));

/**
 * Đây là một intake subsystem mang tính sư phạm
 * cho một intake phổ dụng gồm một motor
 * điều khiển dây đai nối với một puly
 * dẫn động một ống PVC.
 */
public class Intake extends SubsystemBase {
    private Motor m_intakeMotor;
    private boolean m_active;
    
    public Intake(Motor intakeMotor) {
        m_intakeMotor = intakeMotor;
        m_active = true;
    }
    
    // chuyển trạng thái toggle
    public void toggle() {
        m_active = !m_active;
    }
    
    // trả về trạng thái active
    public boolean active() {
        return m_active;
    }
    
    public void run() {
        m_intakeMotor.set(0.75);
    }
    
    public void stop() {
        m_intakeMotor.stopMotor();
    }
}

/* trong opmode của bạn */
Motor intakeMotor = new Motor(hardwareMap, "intake");
Intake intake = new Intake(intakeMotor);
toolOp.getGamepadButton(GamepadKeys.Button.RIGHT_BUMPER)
    .whenPressed(new ConditionalCommand(
        new InstantCommand(intake::run, intake),
        new InstantCommand(intake::stop, intake),
        () -> {
            intake.toggle();
            return intake.active();
        }
    ));

// mã giả để khởi tạo command
ConditionalCommand pressBeacon = new ConditionalCommand(
    new InstantCommand(beaconPresser::pushRed, beaconPresser),
    new InstantCommand(beaconPresser::pushBlue, beaconPresser),
    () -> vision.output() == BeaconColor.RED
);
pressBeacon.schedule();    // lên lịch command
/* Điều này cũng hữu ích trong các sequential command group */

SequentialCommandGroup auto = new SequentialCommandGroup(
    ...,
    new ConditionalCommand(
        new ScheduleCommand(
            // schedule các command
        ),
        new ScheduleCommand(
            // schedule các command
        ),
        ...    // boolean supplier
    ),
    ...
);

public enum Height {
    ZERO, ONE, FOUR
}
public Height height() {
    // một số code để phát hiện chiều cao của starter stack
}
...
SelectCommand wobbleCommand = new SelectCommand(
    // tham số đầu tiên là một map các command
    new HashMap<Object, Command>() {{
        put(Height.ZERO, new PurePursuitCommand(...));
        put(Height.ONE, new PurePursuitCommand(...));
        put(Height.FOUR, new PurePursuitCommand(...));
    }},
    // selector
    this::height
);

public enum Height {
    ZERO, ONE, FOUR
}
public Height height() {
    // một số code để phát hiện chiều cao của starter stack
}
// trả về command cho hành động wobble goal
public Command wobbleCommand() {
    Height rings = this.height();
    switch (rings) {
        case Height.ZERO:
            return ...;
        case Height.ONE:
            return ...;
        case Height.FOUR:
            return ...;
    }
}
...
SelectCommand wobbleCommand = new SelectCommand(
    // truyền vào một command supplier
    this::wobbleCommand
);

/* trong opmode của bạn */
Motor intakeMotor = new Motor(hardwareMap, "intake");
Intake intake = new Intake(intakeMotor);
toolOp.getGamepadButton(GamepadKeys.Button.RIGHT_BUMPER)
    .whileHeld(new InstantCommand(intake::run, intake));
intake.setDefaultCommand(new PerpetualCommand(stopIntakeCommand));
// thực ra không cần như trên; bạn thường làm như sau:
intake.setDefaultCommand(new RunCommand(intake::stop, intake));

SequentialCommandGroup auto = new SequentialCommandGroup(
    ...,
    // schedule command tách khỏi
    // command group
    new ScheduleCommand(forkedCommand),
    // đợi cho đến khi command đó kết thúc
    new WaitUntilCommand(forkedCommand::isFinished),
    ...    // các command khác
);

SequentialCommandGroup auto = new SequentialCommandGroup(
    ...,
    new FunctionalCommand(
        // hành động khởi tạo
        driveSubsystem::resetEncoders,
        // hành động execute
        () -> {
            /* danh sách hành động */
            // lưu ý run() trả về void
        },
        // hành động khi kết thúc
        driveSubsystem::stop,
        // supplier xác định khi nào kết thúc
        () -> {
            /* logic trả về boolean */
        },
        driveSubsystem,
        ...    // các subsystem cần require khác
    ),
    new ScheduleCommand(forkedCommand),
    new WaitUntilCommand(forkedCommand::isFinished),
    ...
);

schedule(
    fooCommand.withTimeout(1000) // kết thúc sau 1000 ms
);

schedule(
    fooCommand.interruptOn(() -> {
        /* BOOLEAN SUPPLIER */
        return ...;
    })
);

schedule(
    fooCommand.whenFinished(() -> {
        /* RUNNABLE */
    })
);

schedule(
    fooCommand.beforeStarting(() -> {
        /* RUNNABLE */
    })
);

schedule(
    fooCommand.andThen(
        barCommand, bazCommand, ...
    )
);

schedule(
    // kết thúc khi fooCommand kết thúc
    fooCommand.deadlineWith(
        barCommand, bazCommand, ...
    )
);

schedule(
    fooCommand.alongWith(
        barCommand, bazCommand, ...
    )
);

schedule(
    // chạy cho đến khi một command kết thúc
    fooCommand.raceWith(
        barCommand, bazCommand, ...
    )
);

// trả về một perpetual command
PerpetualCommand perpetual = fooCommand.perpetually();

// trả về một proxy schedule command
ProxyScheduleCommand proxySchedule = fooCommand.asProxy();