All Classes and Interfaces
Class
Description
The heading-rate feedforward
Swerve hands its aim request (
FieldCentricFacingAngle.withTargetRateFeedforward) while aiming at the hub.A WPILib
Alert that is also logged and shown on Elastic.Configuration data for an arm simulation.
WPILib-backed simulation of a single-jointed arm driven by one or more Kraken X60 motors.
Logs why the auto command ended and how long it ran.
How an auto ended, as logged.
Why the auto command ended.
An auto is selected, its file loaded, and the robot sits on its starting pose (254 2025's "Near
Auto Starting Pose").
What the check needs, from logged inputs.
Runs slow reads, such as files under
/proc and CAN bus status, on one low-priority daemon
thread.The latest value a background read produced.
The battery at rest is charged, and is not the one used in the last match.
The battery IDs this check compares, from logged inputs.
Tracks and logs current draw, power, and cumulative energy consumption across subsystems each
robot loop cycle.
A switch.
Automatically generated file containing build version information.
Caches a DoubleSupplier value so it is computed at most once per scheduler iteration.
Every camera that solves a full pose from tags agrees on the robot's heading, with the gyro and
with each other.
Camera housekeeping, from
params/cameras.json.The CAN buses FM runs on under SystemCore, and the one place a bus name becomes a
CANBus.A cap on how long boot may spend on CAN device configuration that is not working.
Identifies a CAN device by its numeric device ID and the CAN bus name it lives on.
One pre-match self-check, registered with
PreMatchChecks.One check's verdict and the reason for it, in words a drive team can act on.
Verdicts, least to most severe.
Renders a filled circle in a
Mechanism2d canvas using evenly-spaced radial ligaments.AdvantageKit runtime mode.
Utility class for unit conversions.
Tracks start-up and caught crash events, logging them to a file which doesn't roll over
This class and its subclasses remap controller stick inputs.
Feeds AdvantageKit's NetworkTables publisher only what a dashboard needs, at a dashboard's rate.
Every device answering, none rebooted recently, grouped by bus (or by kind, for coprocessors).
One device: its name, its group, and where its logged state comes from.
A finite number, with inclusive bounds.
Receives files the Driver Station laptop pushes after a match: its DS log, and audio and video
recorded at the driver station.
What changes from one event to the next.
This class maps the value of a input to an exponential curve.
Contains various field dimensions and useful reference points.
A short fingerprint of an AprilTag field map, so the robot and each coprocessor can tell whether
they solve with the same tags.
A layout as WPILib AprilTagFieldLayout JSON, for a coprocessor to load.
The Fuel Intake subsystem.
Full-field ball physics simulation for FRC 2026 REBUILT.
Physics feature toggles.
A hub that can be scored in.
One ball in the simulation.
Abstract base class for robot gamepad (Xbox-compatible) controllers.
Configuration for a
Gamepad instance, defining the DriverStation USB port, axis curve
parameters, and whether the controller should be used on this robot.Which Driver Station's controller layout to read (see
GamepadLayout).Comparison type used by axis-based
Trigger factories such as Gamepad.leftYTrigger(Threshold, double).Where an Xbox controller's buttons and axes arrive, which depends on the Driver Station that
sends them, not on the robot controller.
One rejection rule in a source's gate chain.
Robot state a gate may consult, built once per loop from logged inputs so gating replays
deterministically.
Ties the pit-saved file of a hard-stop group (swerve offsets, soft limits) to the robot it was
saved on, so a controller moved to another robot does not bring that robot's values with it.
Every mechanism that relies on its position knows where it is.
The Hood subsystem.
Finds the hood's bottom stop, so its angle does not depend on where it rested at power-on.
One loop's view of the hood, every field from a logged input.
Logged as an input under
Hood/Homing, true on every robot and sim run, so a log says
whether it was recorded with homing.The homing answer for one loop.
Homing constants.
Logged as
Hood/HomingState.Checks, from logged inputs, that the gyros are mounted the way the code is told, against the
drivetrain's own wheel motion.
One loop's readings.
How a gyro's heading follows the wheels' turning, while both are turning.
The Indexer Bed subsystem.
The Indexer Tower subsystem.
The Intake Extension subsystem.
The right deploy axis.
A whole number, with inclusive bounds.
The Jetson Orin as a whole: what the robot tells it, and what the robot checks about it before a
match.
One configured Orin camera, as
Jetson sees it.The Jetson Orin's own topics, as an AdvantageKit input: board health (issue #10, 9a and the
throttle addition), Rewind status (4, 7a), the Jetson's settings (11a) and the active
excluded-tag list (11b).
Hardware layer for the Jetson Orin itself (not one camera): its health and Rewind topics in, and
the robot's commands to it out.
The Jetson's NetworkTables topics under
/photonvision (SpectrumJetson docs/TECHNICAL.md
and docs/REWIND.md).Unchecked exception thrown to signal that the robot code should stop executing immediately.
The Launcher subsystem.
Robot LED subsystem for the 2026 REBUILT season.
Provides a high-level interface to a single Limelight camera for AprilTag-based pose estimation
and basic targeting.
Configuration for a single Limelight camera, including its network-table name and physical
mounting position on the robot.
LimelightHelpers provides static methods and classes for interfacing with Limelight vision
cameras in FRC.
Represents hardware statistics from the Limelight.
Encapsulates the state of an internal Limelight IMU.
Represents IMU data from the JSON results.
Limelight Results object, parsed from a Limelight's JSON results output.
Represents a Barcode Target Result extracted from JSON Output
Represents a Neural Classifier Pipeline Result extracted from JSON Output
Represents a Neural Detector Pipeline Result extracted from JSON Output
Represents an AprilTag/Fiducial Target Result extracted from JSON Output
Represents a Color/Retroreflective Target Result extracted from JSON Output
Represents a 3D Pose Estimate.
Represents a Limelight Raw Neural Detector result from Limelight's NetworkTables output.
Represents a Limelight Raw Fiducial result from Limelight's NetworkTables output.
Represents a Limelight Raw Target/Contour result from Limelight's NetworkTables output.
Represents capture rewind buffer statistics.
Reads one Limelight's MegaTag1 or MegaTag2 estimate into
PoseSourceInputs.Configuration data for a linear (elevator-style) mechanism simulation.
WPILib-backed simulation of a linear (elevator-style) mechanism driven by one or more Kraken X60
motors.
Where the robot's logs go on SystemCore, and keeping them from filling its storage.
Do NOT add any static variables to this class, or any initialization at all.
A short summary of the run, kept as it happens: battery, brownouts, loop overruns, CAN drops and
reboots, Driver Station drops, vision counts, how auto went, alerts raised and peak motor
temperatures.
Abstract base class representing a CTRE TalonFX-driven robot mechanism with common control modes,
telemetry, and convenience
Command factories.Configuration for a
Mechanism, encapsulating the TalonFX hardware configuration,
control request objects, and mechanism-level parameters (gear ratio, soft limits, PID/FF
gains, Motion Magic profile, current limits, etc.).Configuration for a TalonFX follower motor that mirrors the leader.
Buttons shared between bare bindings and modifier chords (LB + A, RT + X, ...), resolved as one
answer from the buttons held.
Everything a
Mechanism reads from its motors in one loop, as an AdvantageKit input.Tracks whether a motor has rebooted since its position was last set, so a homed mechanism stops
trusting a position that restarted from the boot value.
Represents a simulation component that other mechanisms can be attached to.
Discriminates between the two supported mount types so child mechanisms can apply the correct
positioning logic.
Mixin interface for simulation components that can be attached to a
Mount.Common Network Utilities
Publishes params at
<prefix>/<group>/<key> on NetworkTables through AdvantageKit's
LoggedNetwork inputs, so the dashboard's requests are in the log too.Screens each odometry sample before
PoseFusion sees it, so a device that drops off CAN
cannot move the pose.What to hand the estimators.
One odometry sample.
Limits and geometry.
Everything one Orin (Jetson + PhotonVision) camera reported since the last loop, as an
AdvantageKit input: the raw PhotonLib results plus the Jetson's per-camera topics.
Hardware layer for one Orin camera: reads it into
OrinCameraInputs, and carries the few
commands the robot sends it.An Orin camera pose source that uses the robot's heading instead of solving for it.
Which estimate this source makes.
The Orin camera's pose source: reads the camera into logged
OrinCameraInputs, then solves
poses from those inputs with OrinSolver.Turns one Orin camera's logged PhotonLib results into pose observations.
One tunable value, declared in code with a name, type, default, units and optional bounds, and
resolved from the layers described in
Params.The value types a params file and the transport can carry.
Declares the params of one group.
Robot params: values tuned on the robot that survive the next deploy, without editing code.
Where a param's current value came from.
How params reach a dashboard for live tuning.
A published value: what the dashboard last set, and a way to show a value there.
One PhotonVision camera on the Jetson Orin, read with PhotonLib alpha-2 (the robot must stay on
alpha-2: it is the Jetson's wire format).
The robot's pose estimate, and the machinery to compare every source against it.
One robot-pose measurement from one source, before any gating.
What produced an observation.
One robot-pose source: a device, its own gate chain, and its own trust model.
Gate outcome for one observation.
Everything a pose source reported since the last loop, as an AdvantageKit input.
Hardware layer for one pose source, AdvantageKit style.
A position written to a motor off the main thread, tracked until the motor's readings show it.
Pre-match self-checks: a registry of
Checks that run while the robot is disabled and add
up to one GO / NO-GO.The one command the robot sends a QuestNav: where the robot is, so it can re-origin.
Meta Quest running QuestNav, over NetworkTables table
QuestNav.The few QuestNav protobuf messages FM uses, encoded and decoded by hand.
A decoded device status.
A decoded frame.
Rewrites the radio's status JSON in "RadioStatus/Status" before any log file or dashboard gets it,
keeping only fields known to be safe and blanking the rest.
Identifies the specific RoboRIO that is running, keyed by its serial number.
FM (2026 "Final Machine") on SystemCore, competing as 8515.
RobotBumpSim is a standalone robot-bump physics simulation for MapleSim.
Counts robot loops so work can be done "once per loop" or "every Nth loop" without a timer.
Every class that declares params.
Configuration data for a roller mechanism simulation.
WPILib-backed simulation of a roller (flywheel) mechanism driven by a single Kraken X60 motor.
Facts about where the code is running that logic depends on, as an AdvantageKit input.
Flags settings that are not at their defaults: a field layout other than the season's, a practice
profile left on, a dashboard switch flipped in the pits.
The fixed shots, one per parking spot, from the offseason bot's set shots (463c465, fa1376b)
less its hub-face shot, which FM cannot make.
Immutable snapshot of all quantities needed to command the drive, hood, and flywheel
subsystems for a single shot.
Decides, once per loop, whether fuel may be fed into the flywheel.
Why the feed is being held, or
ShotGate.Blocker.NONE.The gate's answer for one loop.
Why fuel is (or is not) going in.
One loop's view of the shot, every field from a logged input or something computed from one.
Gate tolerances.
One row per volley, under
ShotLog/: what was aimed, and what the mechanisms were doing,
on the loop the feed opened.Everything a row needs that the log cannot look up itself.
Shared high-frequency simulation loop.
Shared wiring between a
TalonFX and the WPILib physics sims in this package.A scripted drive for the desktop simulation, so the localization testbed can be exercised (and
checked) without a driver: sit disabled so the Limelights seed the pose, then drive a lap of
straights, strafes and spins in teleop while every pose source is logged.
The script's two non-driver actions, as an AdvantageKit input so a replay of a scripted run
performs them on the same loop (the driving itself is already replayed, through the logged
Driver Station).
Simulated cameras for every pose source, on PhotonLib's
VisionSystemSim.One simulated Limelight: PhotonLib results read once per loop, shared by MT1 and MT2.
A Limelight source backed by a PhotonLib sim camera.
Simulated QuestNav: reports truth in its own frame, which lines up with the field only after
SimVision.QuestSimIO.resetPose(Pose2d), plus a random-walk drift.Wraps a CTRE CANcoder and applies Spectrum-specific configuration.
Selects how the TalonFX reads position data from the remote CANcoder.
Configuration parameters for a
SpectrumCANcoder.CANdle-based addressable LED subsystem that wraps a CTRE
CANdle and exposes a rich
library of pattern factories (solid, stripe, blink, breathe, rainbow, chase, bounce, gradient,
ombre, wave, countdown, etc.).Functional interface for a LED pattern that drives a segment of a
CANdle strip.Configuration for a
SpectrumLEDs subsystem instance.Base robot class for Spectrum robots on SystemCore: AdvantageKit's
LoggedRobot, which
runs the loop, records every input, and drives replay.Represents a global or subsystem-specific state that can be used as a Trigger.
Chooses how much the estimator should trust an observation that has passed every gate.
Standard deviations handed to the pose estimator.
Text, such as a camera name or a mode.
FM's swerve drivetrain: Phoenix 6's
SwerveDrivetrain for control and 250 Hz odometry,
with the robot pose owned by PoseFusion on the main loop so it can be replayed.Deliberate odometry error in simulation, so the comparison between vision sources has
something to correct.
Publishes the raw per-module CANcoder data that swerve alignment needs.
Everything the drivetrain reads from CTRE in one loop, as an AdvantageKit input.
The swerve CANcoder magnet offsets as params, group
swerve, so a module re-zeroed in the
pit (SwerveAlignment) can be saved without a code change.Watches the things that made the robot fall behind on 2026-09-05 and says so on the dashboard.
An extended Kalman filter over (x, y, heading) that takes every camera's tags one at a time, in
the style of 971's AOS localizer: each tag is a bearing and a distance from its camera, so a
single or far tag still corrects the pose at a low weight instead of being thrown away, and every
camera feeds the same estimate.
Per-camera tag counts, and this loop's residuals of the tags that passed.
Which AprilTag field the robot solves with, as a logged input (
Vision/FieldMap/Name and
Hash).The field vision solves with.
One AprilTag seen by one camera in one frame: where the tag's centre was, relative to the camera.
Creates CANTalon objects and configures all the parameters we care about to factory defaults.
Telemetry and logging facade, backed by AdvantageKit.
Named fault conditions that can be surfaced as structured log entries.
Priority levels for printing to the console.
What the Pigeon says about the robot's attitude and knocks, derived from logged inputs so it
replays.
Latches a mechanism to a stop once it has stayed out of tolerance of its closed-loop goal for a
debounce time: a jam, a slipped belt, a motor fighting a hard stop.
Represents a trio of three objects.
A number that can be changed from a dashboard at runtime without redeploying, for tuning gains,
speeds and other constants.
Whether dashboards may change tunable values.
Basic helpers imported from the 254 lib (1678-2024).
FM's multi-source localization testbed: up to three Limelights, three Orin/PhotonVision cameras
and a QuestNav, each gated on its own and each logged well enough to compare after the fact.
Gate chains and trust models for FM's pose sources.
Ring buffer of chassis yaw-rate samples, for the lookback spin gate.