A Software Engineer's Guide to the FTC Android Studio Workspace
FIRST-Tech-Challenge/FtcRobotController
This project provides a structured and robust framework for programming FTC robots. From a software engineering perspective, this means
Abstraction and Modularity
The codebase is designed with clear abstractions for hardware components (motors, sensors, controllers). This allows us to focus on the logic of our robot's behavior rather than getting bogged down in low-level hardware details. We can create reusable modules for specific robot functions (e.g., a DriveTrain class, an ArmControl class).
Android Development Foundation
It leverages Android Studio and the Android SDK. This means we're working with a familiar, powerful, and widely-used development environment. We can utilize concepts like Activities, Services, Intents, and Java/Kotlin for our robot's control system.
Event-Driven Programming
Robot control is inherently event-driven. The FTC SDK provides mechanisms to handle inputs from gamepads, sensor readings, and timer events. This aligns perfectly with common software engineering patterns for handling asynchronous operations.
Version Control Ready
The project is set up to be used with version control systems like Git. This is crucial for collaborative development, tracking changes, debugging regressions, and managing different features or robot designs.
Testing and Debugging Tools
Android Studio offers a rich set of tools for debugging, profiling, and testing our code. We can use logcat to monitor robot behavior, set breakpoints, and even simulate some aspects of robot operation.
Community and Resources
Being an open-source project associated with FIRST Tech Challenge means there's a community of developers and ample resources (documentation, forums, examples) available to help us learn and troubleshoot.
Getting started is pretty straightforward, especially if you're familiar with Android development
Install Android Studio
If you don't have it already, download and install the latest version of Android Studio from the official Android Developers website.
Clone the Repository
The first step is to get the FtcRobotController source code. You'll typically do this by cloning the GitHub repository.
git clone https://github.com/FIRST-Tech-Challenge/FtcRobotController.git
Open in Android Studio
Once cloned, open the FtcRobotController folder as an existing Android Studio project.
Connect Your FTC Robot Controller
Ensure your FTC robot controller is connected to your computer via USB and is powered on.
Build and Deploy
Android Studio will build the project. You can then deploy the application to your robot controller. This usually involves selecting your device from the dropdown menu and clicking the "Run" button.
Configure OpModes
The core of your robot's logic will reside in OpModes. These are special classes that the FTC SDK recognizes and runs on the robot. You'll write your custom robot code within these OpModes.
Let's look at a basic example of a Linear OpMode. Linear OpModes run sequentially and are great for simpler autonomous routines or driver-controlled modes where you want a clear start-to-finish execution flow.
Imagine we want to create an OpMode that drives the robot forward for 2 seconds and then stops.
First, you'll create a new Java or Kotlin class that extends LinearOpMode.
// Import necessary classes
import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.util.ElapsedTime;
// Annotate your OpMode to make it discoverable by the Driver Station
@TeleOp(name="Basic Forward Drive", group="Tutorial") // You can change the name and group
public class BasicForwardDrive extends LinearOpMode {
// Declare your motor variables
private DcMotor leftFrontDrive;
private DcMotor rightFrontDrive;
private DcMotor leftBackDrive;
private DcMotor rightBackDrive;
// Timer for controlling duration
private ElapsedTime runtime = new ElapsedTime();
@Override
public void runOpMode() {
// --- Initialization ---
// Map hardware devices to variables. Make sure the names in the configuration
// on the Driver Station match these strings.
leftFrontDrive = hardwareMap.get(DcMotor.class, "left_front_motor");
rightFrontDrive = hardwareMap.get(DcMotor.class, "right_front_motor");
leftBackDrive = hardwareMap.get(DcMotor.class, "left_back_motor");
rightBackDrive = hardwareMap.get(DcMotor.class, "right_back_motor");
// Most robots need the motor on one side to be reversed to the other.
// Standard configuration assumes the first motor is reversed.
leftFrontDrive.setDirection(DcMotor.Direction.REVERSE);
leftBackDrive.setDirection(DcMotor.Direction.REVERSE);
// You might need to adjust directions based on your robot's wiring.
// Set motors to break (stop) when power is set to zero
leftFrontDrive.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
rightFrontDrive.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
leftBackDrive.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
rightBackDrive.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
// Wait for the game to start (driver presses PLAY)
telemetry.addData("Status", "Initialized");
telemetry.update();
waitForStart();
runtime.reset(); // Start the timer
// --- Main Robot Logic ---
// Drive forward for 2 seconds
double forwardSpeed = 0.5; // 50% power
double driveDuration = 2.0; // seconds
// Set motors to drive forward
leftFrontDrive.setPower(forwardSpeed);
rightFrontDrive.setPower(forwardSpeed);
leftBackDrive.setPower(forwardSpeed);
rightBackDrive.setPower(forwardSpeed);
// Keep running until the timer exceeds the duration
while (opModeIsActive() && (runtime.seconds() < driveDuration)) {
// Update telemetry to show elapsed time
telemetry.addData("Status", "Driving Forward");
telemetry.addData("Time Elapsed", runtime.toString());
telemetry.update();
// This loop will simply wait for the time to pass.
// In a more complex OpMode, you might have other logic here.
}
// --- Stop the Robot ---
// Stop all motors after the duration
leftFrontDrive.setPower(0);
rightFrontDrive.setPower(0);
leftBackDrive.setPower(0);
rightBackDrive.setPower(0);
// Update telemetry to show completion
telemetry.addData("Status", "Stopped");
telemetry.update();
// OpMode finishes
}
}
Explanation of the code
@TeleOp(...)
This annotation registers your OpMode with the FTC system, making it selectable on the Driver Station app.
extends LinearOpMode
This signifies that this is a linear OpMode, which executes code from top to bottom after waitForStart().
hardwareMap.get(DcMotor.class, "...")
This is how you access hardware components configured in your robot's "Hardware Configuration" file on the Driver Station.
setDirection(DcMotor.Direction.REVERSE)
Essential for making sure motors on opposite sides of the robot spin in directions that cause forward motion when given positive power.
setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE)
This makes the motors actively resist rotation when their power is set to zero, providing a braking effect.
waitForStart()
This pauses execution until the driver presses the "Play" button on the Driver Station app.
runtime.reset() and runtime.seconds()
The ElapsedTime object is a handy utility for timing events.
setPower(speed)
This is how you command the motors to move. The speed is a double value between -1.0 (full reverse) and 1.0 (full forward).
opModeIsActive()
This checks if the OpMode is still running (i.e., the driver hasn't pressed "Stop").
telemetry.addData(...) and telemetry.update()
These are used to display information (like status or sensor readings) on the Driver Station app, which is invaluable for debugging.