Project Structure

Workshop/
  build.gradle                 how to build, and which libraries
  settings.gradle              where Gradle finds WPILib
  gradlew, gradlew.bat         run Gradle without installing it
  .wpilib/
    wpilib_preferences.json    your team number
  vendordeps/
    CommandsV3.json            one file per vendor library
    Phoenix6-26.70.0-alpha-2.json
  src/main/deploy/             files copied onto the robot
  src/main/java/first/
    Main.java                  starts the program. Never edited
    robot/
      Robot.java               owns the mechanisms
      mechanisms/
        Arm.java               one class per mechanism
        Flywheel.java
      opmode/
        MyTeleop.java          one class per mode
        MyAuto.java
  build/                       made by every build. Never edited

The mechanisms folder does not exist yet. You make it in the next lesson. Everything else is already there from the New Project Creator.

Three things you leave alone. Main.java holds one line that matters, RobotBase.startRobot(first.robot.Robot::new). Its own comment says to leave the file alone. build/ is rewritten on every build, so an edit there disappears. The gradle/wrapper files pin the Gradle version for everyone on the team.

Robot.java owns the mechanisms, one public final field each, and runs the scheduler once per loop in robotPeriodic(). Its constructor is where a binding goes that must work in every mode. On this course that constructor stays empty.

1public class Robot extends OpModeRobot {
2  public final Arm arm = new Arm();
3  public final Flywheel flywheel = new Flywheel();
4 
5  public Robot() {}
6 
7  @Override
8  public void robotPeriodic() {
9    Scheduler.getDefault().run();
10  }
11}

A mechanism class is one physical thing on the robot. It implements Mechanism and keeps its motors and sensors private. Its public methods either return a Command, like arm.vertical(), or answer a question, like arm.isAtTarget(). Nothing outside the class touches the motor.

An OpMode class is one entry on the driver station list. @Teleop or @Autonomous above the class puts it there. Its constructor binds buttons to commands, and it reaches the mechanisms through robot.arm and robot.flywheel.

There is no Constants file on any branch of this course. A number sits in the class that uses it, next to the line that uses it.

• CAN IDs sit where the device is made: new TalonFX(21, canivore).
• Gains sit in the configuration you paste from Tuner X, in the mechanism's constructor.
• Setpoints sit in the command that asks for them: setVelocity(75.0) inside runFast().
• Tolerances are a private final field at the top of the mechanism.

When an OpMode needs to know whether the arm has arrived, it calls robot.arm.isAtTarget(). It never compares angles itself, so the tolerance stays in one place and changes in one place.

Ask what the code talks to.

• A motor or a sensor. The mechanism that owns it, as a private method.
• Something one mechanism does. A public method on that mechanism that returns a Command.
• A button. The constructor of the OpMode it belongs to. A button for every mode goes in the Robot constructor.
• Two mechanisms working together. The OpMode that runs the routine. spinUpWhenReady lives in MyTeleop for that reason.
• A vendor library. vendordeps/, added through the WPILib Vendor Dependencies view, never by copying a jar.
• A file the robot reads while running. src/main/deploy/. A deploy copies it onto the SystemCore.

Open the Explorer in VS Code and expand src/main/java/first. Then sort the four quiz questions below without scrolling back up.