Programming Pathway¶

The Programming pathway prepares students to move from basic logic and robot control to architecture, autonomous systems, simulation, and mentoring. The focus is on writing software that is readable, testable, field-ready, and aligned with how the robot is actually built.

Core Public Resources¶

Level Pages¶

Level 0: Exposure¶

Learning objectives

Understand what code does on a robot
Learn variables, conditionals, loops, and input-output concepts
Connect software actions to motors, sensors, and driver controls

Required skills

Follow step-by-step coding instructions
Read basic pseudocode
Run and modify a simple example program

Core concepts and theory

Program flow
Inputs and outputs
Teleoperated versus autonomous behavior
Safe testing habits

Hands-on activities

Write a simple LED blink or print loop
Change a timed movement example
Map one button to one motor action on a training robot

Suggested mini-projects

Make a robot move forward for one second
Add a button that starts and stops a mechanism

Assessment of mastery

Student explains how a button press changes robot behavior
Student modifies and runs a basic program with help

Common mistakes and troubleshooting

Editing multiple things at once
Testing without understanding the starting state
Assuming code is deployed when the robot is still running old code

Expected outcomes

Ready for guided work in an official FRC language

Level 1: Foundations¶

Learning objectives

Build a simple robot project in Java, C++, or Python
Control motors and read operator input using WPILib
Organize code into clear classes or modules

Required skills

Create and deploy a basic project
Read compiler errors with help
Use source control in a beginner-safe workflow

Core concepts and theory

Robot lifecycle basics
Command-based structure at a beginner level
Joystick mapping, deadbands, and drive control
Constants and why magic numbers are risky

Hands-on activities

Create a drive subsystem
Bind buttons or triggers to actions
Print or publish basic telemetry

Suggested mini-projects

Implement arcade drive
Add a motorized intake controlled by a button

Assessment of mastery

Student deploys and drives a simple robot safely
Student explains where hardware definitions and controls belong

Common mistakes and troubleshooting

Mixing hardware setup with driver logic
Hardcoding values without explanation
Failing to confirm motor IDs and wiring with Electrical

Expected outcomes

Can contribute basic teleop functionality under supervision

Level 2: Application¶

Learning objectives

Build and debug multiple subsystems
Integrate sensors and feedback into robot behavior
Use dashboards, logs, and simulation to shorten debug cycles

Required skills

Read encoder, gyro, beam break, or limit switch data
Tune basic control loops with guidance
Work from requirements supplied by Mechanical and Electrical

Core concepts and theory

Sensor validation
State transitions and subsystem ownership
Dashboard-based debugging
Introductory PID and autonomous sequencing

Hands-on activities

Add sensors to a mechanism
Display robot state and telemetry
Write a short autonomous routine that uses measured distance or angle

Suggested mini-projects

Shooter wheel speed control
Elevator with limit protection
Autonomous drive-forward-and-score routine

Assessment of mastery

Student delivers a functioning subsystem or autonomous routine
Student diagnoses a seeded sensor or tuning issue
Student documents expected inputs, outputs, and tuning notes

Common mistakes and troubleshooting

Using unverified sensor data
Ignoring reset and initialization behavior
Tuning without capturing observations
Debugging alone instead of checking the hardware interface first

Expected outcomes

Can own software for a simple mechanism or autonomous action

Level 3: Leadership¶

Learning objectives

Architect a full robot codebase
Lead command structure, subsystem interfaces, and autonomous design
Coordinate programming decisions with real hardware constraints

Required skills

Break large behavior into subsystems and commands
Review code for maintainability and field reliability
Use simulation and logging to test before robot access

Core concepts and theory

Command scheduling and subsystem requirements
Motion control and sequencing
Reusable abstractions and interface contracts
Event-driven debugging during build and competition

Hands-on activities

Design the robot project structure
Lead integration of drivetrain, manipulator, and operator interface
Review logs and field failures after practice matches

Suggested mini-projects

Complete autonomous routine library
Practice robot simulation harness
Shared diagnostics dashboard

Assessment of mastery

Student leads a code review and justifies architecture choices
Robot executes competition-relevant behavior reliably
Student can trace a software issue to its root cause across code and hardware

Common mistakes and troubleshooting

Overengineering abstractions too early
Letting naming drift between code and hardware
Poor ownership boundaries between subsystems
Neglecting operator usability

Expected outcomes

Can lead software development for an FRC robot

Level 4: Mentor¶

Learning objectives

Create sustainable programming standards and training systems
Teach architecture, debugging, and test discipline
Improve year-over-year code reuse without carrying forward bad patterns

Required skills

Mentor beginners through deployment, debugging, and code review
Evaluate new libraries and vendor features carefully
Build documentation that survives team turnover

Core concepts and theory

Long-term architecture stewardship
Training progression and review design
Reliability, observability, and operator-centered software

Hands-on activities

Run a command-based workshop
Maintain a template project or training robot repository
Build post-season refactors based on competition lessons

Suggested mini-projects

Team programming handbook
Simulation-first training project
Reusable subsystem templates with documentation

Assessment of mastery

New students reach productive contribution faster because of the training system
Team codebase quality improves across seasons, not just within one robot

Common mistakes and troubleshooting

Treating advanced patterns as goals instead of tools
Building standards no one can maintain
Failing to include non-programmers in debugging workflows

Expected outcomes

Can mentor a programming team, define architecture standards, and support multiple robots or teams