diff --git a/examples/build.gradle b/examples/build.gradle index 183721d..f9e09db 100644 --- a/examples/build.gradle +++ b/examples/build.gradle @@ -16,7 +16,7 @@ spotless { java { target fileTree(rootDir) { include "**/*.java" - exclude "**/build/**", "**/.gradle/**", "stage0/snippets/**" + exclude "**/build/**", "**/.gradle/**", "stage0/snippets/**", "stage1/snippets/**" } licenseHeaderFile rootProject.file('gradle/LICENSE_HEADER') } diff --git a/examples/stage1/snippets/Main.java b/examples/stage1/snippets/Main.java new file mode 100644 index 0000000..d8d6f48 --- /dev/null +++ b/examples/stage1/snippets/Main.java @@ -0,0 +1,17 @@ +/* + * Copyright 2026 FRCSoftware + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +// [main] +import org.wpilib.framework.RobotBase; + +public final class Main { + private Main() {} + + public static void main(String... args) { + RobotBase.startRobot(first.robot.Robot.class); + } +} +// [/main] diff --git a/src/config/sidebarConfig.ts b/src/config/sidebarConfig.ts index 29e6e02..400bb70 100644 --- a/src/config/sidebarConfig.ts +++ b/src/config/sidebarConfig.ts @@ -92,19 +92,36 @@ export const sidebarSections: Record = { label: 'Stage 1', collapsed: true, items: [ - // { - // label: 'Stage 1 Introduction', - // slug: 'learning-course/stage-1a-commands/overview', - // }, { - label: 'Stage 1A: TBD', + label: 'Stage 1 Introduction', + slug: 'learning-course/stage1/stage-overview', + }, + { + label: 'Stage 1A', collapsed: true, - items: [], + items: [ + { + label: 'Stage 1A Introduction', + slug: 'learning-course/stage1/stage1a/stage-overview', + }, + // { + // label: 'TBD', + // slug: 'stage-1a-commands/the-command-body', + // }, + // { + // label: 'TBD', + // slug: 'stage-1a-commands/commands-and-mechanisms', + // }, + ], }, { label: 'Stage 1B: Commands', collapsed: true, items: [ + { + label: 'Stage 1B Introduction', + slug: 'learning-course/stage1/stage1b/stage-overview', + }, { label: 'The Concepts', slug: 'learning-course/stage1/stage1b/command-based-overview', diff --git a/src/content/docs/learning-course/stage1/stage-overview.mdx b/src/content/docs/learning-course/stage1/stage-overview.mdx new file mode 100644 index 0000000..118472b --- /dev/null +++ b/src/content/docs/learning-course/stage1/stage-overview.mdx @@ -0,0 +1,24 @@ +--- +title: Stage 1 Overview +description: An overview of Stage 1 +prev: false +next: stage-1a/stage-overview +--- + +Congratulations! Whether you already know Java, have programmed an FRC robot before, +or are a complete beginner, you should have a good grasp of the basic syntax of the Java language by now. +In Stage 1, we'll be moving on to the exciting part: actually writing code for a robot! +It might seem daunting at first, but the best way to think through it is to focus on understanding +how each individual component of the code works, instead of trying to tackle it all at once. + +This stage covers how to fully program a working kitbot for the 2026 FIRST Robotics Competition game, +REBUILT. +You'll start at stage 1A, which covers a simple way to code the kitbot. +Then, you'll move on to stage 1B, which uses a slightly more complex paradigm known as commands. +In addition, you'll also get to debug your robot in a simulation, to check if your code works! +Feel free to play around with the robot and control it in sim once you've finished! + +This stage is composed of the following sub-stages: + +- Stage 1A +- WIP diff --git a/src/content/docs/learning-course/stage1/stage1a/stage-overview.mdx b/src/content/docs/learning-course/stage1/stage1a/stage-overview.mdx new file mode 100644 index 0000000..e919b5d --- /dev/null +++ b/src/content/docs/learning-course/stage1/stage1a/stage-overview.mdx @@ -0,0 +1,119 @@ +--- +title: Stage 1A Overview +description: An overview of Stage 1A +prev: ../stage-overview +next: false +--- + +import YouTube from '../../../../../components/YouTube.astro'; + +Now, before we get into the depths of the robot code, it's useful to look at a high-level overview of the contents of a +typical WPILib project. +As your code gets more advanced, you'll see more folders and files appear, but they're all controlled +by the same basic components. +Below, you can see the sample file structure you'll be starting off with as a template for Stage 1A. +If your robot has REV electronics, then the template folder's name will be `rev/` instead of `ctre/` + +### Stage 1A Template Structure + +{/* rli:ignore */} + +```text +ctre/ +├── src/main/ +| ├── java/first/ +| | ├── robot/ +| | | ├── opmode/ +| | | | ├── MyAuto.java +| | | | ├── MyTeleop.Java +| | | ├── simulation/ +| | | | ├── DrivetrainSim.Java +| | | | ├── SingleFlywheelSim.java +| | | ├── Robot.java +| | ├── Main.java +``` + +You'll notice that we're skipping a lot of files here, because you don't have to edit those. +What's great about about using a framework +like WPILib is that it automatically generates these files when you create a new project, so you can get started coding quicker. +The other folders, like `src/main/deploy/` for example, will come in handy as your robot code becomes more advanced. +Thus, the only files shown above are the ones directly responsible for controlling what our kitbot will do. + + + +### `Main.java` + +The first file to take note of is the `Main.java` file; this is the entrypoint for any Java project in real life. +Its contents are pretty short and sweet (comments and package declaration removed for brevity): + +```java stage1/snippets/Main.java#main + +``` + +You can see that all the `Main.java` file is doing is, quite literally, starting up the robot, +so there's really no reason to edit this file for now. + + + +### `Robot.java` + +But what is that one line in `Main.java` doing? +{/* rli:ignore */} + +```java +RobotBase.startRobot(first.robot.Robot.class); +``` + +It seems to be "starting" an instance of the `first.robot.Robot` class, and if we go to that class file, we end up at `Robot.java`. +This is the core of your robot code, where: + +- your subsystems are defined +- your controls are binded +- your opmodes are modified and used +- your debugging data is logged (aka telemetry). + + + +We'll go through this file, as well as all of the above functionalities, more in detail later. + +### `opmode/` + +For those who are used to WPILib 2026 and earlier versions, this will probably be the most significant change. +In WPILib 2027 and later versions, robot frameworks are getting a new way to control the current "mode" of the robot: OpModes. +We'll talk about this a bit more in-depth later, but they essentially allow you to define various "states" for a robot during +autonomous and teleop, which can then be set directly through the FIRST Driver Station. +This would be useful, for example, +when picking what autonomous routine to run without having to push a different version of the code for every single match. +WPILib 2027 decouples many of the functions that used to be in `Robot.java` and moves them to separate files for autonomous +and teleop periods, making it easier to differentiate what functionalities the robot has during each stage of the match. + +### `simulation/` + +These are the files that control simulation of the robot, allowing you to test code without actually having a physical robot in front of you. +We've set this up for you already; you'll just have to set up the simulation software yourself, which we'll cover at the end of Stage 1A. + +### The 2026 Kitbot + +But what is all this code actually going to control? Well, the answer is the 2026 FIRST Robotics Competition kitbot, the best starting point +for new FRC teams, as well as the simplest robot to get fully working. +You can watch the below video to learn more about what functionalities the kitbot has. +If you're a bit confused after watching that video, don't worry. +We'll explain the kitbot more in depth in the next section. + + + +And that's all you need to know to get started! The rest of Stage 1A will cover how to get from the template code to a working kitbot. + +This stage will cover the following topics: + +- WIP diff --git a/src/content/docs/learning-course/stage1/stage1b/stage-overview.mdx b/src/content/docs/learning-course/stage1/stage1b/stage-overview.mdx new file mode 100644 index 0000000..7ceb62d --- /dev/null +++ b/src/content/docs/learning-course/stage1/stage1b/stage-overview.mdx @@ -0,0 +1,29 @@ +--- +title: Stage 1B Overview +description: An overview of Stage 1B +--- + +Stage 1A used a simple sequential approach to controlling the kitbot. +But real robots need to respond to many inputs at once, like button presses, sensor data, and vision. +Command-based programming solves this by modeling robot behavior as commands (actions) triggered by triggers (events). + +## Key Concepts + +Commands define individual robot actions (deploy the intake, index a game piece, drive based on joystick inputs). +Triggers define when commands should run (controller input, sensor data reaches a certain threshold, the start of autonomous or teleop). +Mechanisms represent the physical robot mechanisms that commands require and control (intake, indexer, drivetrain). + +## Stage 1B Goals + +By the end of Stage 1B, you'll rewrite your Stage 1A kitbot code into a command-based architecture, adding controller bindings, default commands, and simple autonomous routines. + +This stage will cover the following topics: + +- [The Concepts of Command-Based Programming](https://frcsoftware.org/learning-course/stage1/stage1b/command-based-overview/) +- [The Body of a Command](https://frcsoftware.org/learning-course/stage1/stage1b/the-command-body/) +- [Commands & Mechanisms, Part 1](https://frcsoftware.org/learning-course/stage1/stage1b/commands-and-mechanisms/) +- [Triggers and Scheduling](https://frcsoftware.org/learning-course/stage1/stage1b/triggers/) +- [Commands and Mechanisms, Part 2](https://frcsoftware.org/learning-course/stage1/stage1b/commands-and-mechanisms-pt2/) +- [Exercise: Kitbot Rewrite, Pt 1](https://frcsoftware.org/learning-course/stage1/stage1b/command-based-kitbot/) +- [Suppliers in Command-Based](https://frcsoftware.org/learning-course/stage1/stage1b/suppliers-in-command-based/) +- [Exercise: Kitbot Rewrite, Pt 2](https://frcsoftware.org/learning-course/stage1/stage1b/command-based-kitbot-pt2/)