All Classes and Interfaces
Class
Description
Steps that use several parts together, written once (in
Actions.java) and started by a
button in TeleOp or used as a step in an autonomous.Turns a camera target into a turn power, safely: no target, an old picture, or no bearing all
give 0 (the robot never turns toward a target it cannot see now).
Buzzes the gamepad when an error is small, for example when the robot is aimed at a target.
Finds the camera offset for aiming: where the target sits in the camera's view when the LAUNCHER
points straight at it.
Red or blue.
Angle helpers, in degrees.
An arm that swings on one motor, with named angles in degrees.
One autonomous, in one short file: the list of
Steps.What a running
AutoStep can use.Autonomous moves for a mecanum OR standard (tank) robot, using the wheel encoders and the IMU.
How a move ended.
Tuning for
AutoDrive (autonomous encoder and IMU moves).An autonomous written as a list of named steps.
One step of an autonomous routine: "drive 24 inches", "raise the lift", "wait 1 second".
Runs slow jobs (a network request, a camera setting) on a separate thread, so the robot's loop
never waits for them.
Makes sensor and encoder reads much faster with "bulk reads".
A camera that finds AprilTags: a Limelight 3A or a webcam.
The math behind the Characterizer: from a log of power, battery voltage and speed, it finds the
motor's feedforward numbers (see control/Feedforward): power = kS x sign(speed) + kV x speed +
kA x acceleration (+ kG for a lift).
One fit.
Measures how the real robot moves, so the simulator (and your code) can use real numbers: for the
drivetrain, each lift or arm, and each flywheel, it finds the feedforward numbers (kS = power to start
moving, kV = power per speed, kA = power per speeding-up, kG = power to hold a lift) and how fast a
flywheel coasts down.
A lift, arm or flywheel to measure.
A list on the Driver Station to choose from with the D-pad (for example every servo in the
configuration).
A claw on one servo:
open and closed, plus any other positions you name.Connects gamepad buttons to robot actions in one place.
Gamepad buttons.
Which gamepad: G1 = gamepad1 (usually the driver), G2 = gamepad2 (usually the operator).
The two analog triggers.
The team's TeleOp and button map in one file,
Controls.java.Odometry from dead wheels: unpowered omni wheels ("pods") on encoder ports.
Where the modules find their motors, servos and sensors by configuration name.
The math that turns stick values into left and right powers for a standard (tank) drive.
The drivetrain in
Robot.java: mecanum or standard (tank), its motor names, the motor and
wheel, and how the Control Hub is mounted (for the IMU, the turn sensor).The drivetrain type, the motor names and directions, and a power limit.
The kind of drivetrain.
Standard TeleOp driving from one gamepad, for mecanum AND standard (tank) robots, in one line per
loop.
Which way the robot faces compared with the DRIVER, for field-centric driving.
Finds the autonomous drive numbers in
RobotSettings.auto(): the wheel size and (mecanum)
the strafe correction.The easiest way to write an autonomous: fill in a few methods, and list your steps.
A whole TeleOp where you only write what is special about YOUR robot: its mechanisms, the
operator's buttons, and any extra screen lines.
Pushes ONE game piece into the launcher when asked.
The power a motor needs for a speed, worked out from how the motor behaves ("feedforward"), instead
of waiting for an error to build up like a PID does.
Where the robot is on the field: x and y in inches, heading in degrees
(counterclockwise is positive, like the IMU).
The arithmetic behind the finders, kept apart so it can be tested on a laptop.
The shared frame of every finder: INIT, a loop that never waits, the "copy into your code" lines,
saving them to the results file, and stopping everything at the end (even after an error).
What a finder found, as lines of code ready to copy.
A flywheel (shooter wheel) that holds a speed in RPM, says when it is ready, and notices shots.
Finds a flywheel's speed-control numbers.
A ready-made "check every part" OpMode.
Gets devices from the robot configuration, with clear error messages.
Starts the IMU (the hub's built-in turn sensor) in one line, and reads the heading.
Feeds ONE game piece at a time into a launcher: a servo that pushes, a CR servo or a motor that runs
for a moment.
A menu for the INIT screen: choose alliance, start delay, route and more with the gamepad,
before pressing START.
A roller that pulls game pieces in (and pushes them out): one motor, or one or more continuous
rotation (CR) servos.
Tells when a motor is jammed: it is asked to spin but barely turns (or draws too much current)
for a while.
Joins a flywheel, a feeder, and optionally a hood, a shot table and any "ready" checks into one
shooter: spin up, wait until everything is ready, feed, repeat.
A flywheel launcher: a motor that spins a wheel to a speed, and an
Indexer that feeds one
piece at a time once the speed is right.What the launcher is doing (for telemetry).
A lift (a slide that goes up and down) on one motor, with named heights and an optional bottom
switch.
Tries a few camera settings one after the other, counts how many pictures see AprilTags with each,
and keeps the best one.
AprilTags with a Limelight 3A.
Measures how fast your OpMode loop runs.
Remembers what autonomous knew, for TeleOp: the alliance and the robot's pose.
Counts down a match period and runs "cues" at set times, for example a gamepad buzz with
20 seconds left, so drivers do not have to watch the field clock.
Small math helpers that robot code needs all the time.
Drives a four-wheel mecanum chassis.
The math that turns "forward, right, turn" into four mecanum wheel powers.
A rule a module follows every loop while it is on: a turret following the target, a launcher
setting its speed from the distance.
Speed-profile math for autonomous moves.
A feeder driven by a motor (a roller, belt or indexer wheel): runs for a set time per piece,
or until a sensor sees the piece leave.
Finds a motor mechanism's numbers (a lift, an arm, a turret): its limits in encoder counts, the
positions you want, and its top speed.
What
Lift and Arm share: a motor that goes to named positions and holds them
(a PositionMotor inside), with its numbers from Tunables.java.Encoder counts per turn and top speed of the common FTC motors, by the same ids as the simulator's
parts catalog (
sim/parts/parts.json, docs/guides/parts-catalog.md): "gobilda-5203-312",
"rev-hd-hex-20"...One motor: encoder counts per output-shaft turn, and its free (no-load) speed in RPM.
Sets up a motor in one readable chain.
The robot's odometry, one line in
Robot.java: what tells the robot where it is on the field.Checks and measures the odometry of the robot in five files (lesson 7): which way each pod counts,
how far it measures, and where the pods sit (the offsets).
Odometry from a SparkFun OTOS (Optical Tracking Odometry Sensor): a camera-like sensor under the robot
that watches the floor move, with its own IMU.
One gamepad in
Controls.java: every button and stick, by name.One button or trigger.
One stick direction: up and right are +, from -1 to 1.
The wheels and rollers (and the servo ids) of the simulator's parts catalog (
sim/parts/parts.json,
docs/guides/parts-catalog.md), by the same ids: "gobilda-hogback-96", "offset-tubing-90"...One wheel or roller: its size in millimetres.
A path follower from another library (Pedro Pathing, through the ftc-helper-lib "pedro" module), plugged
into the robot in five files:
follower(Pedro.follower(...)) in Robot.java, then
s.follow("To the goal", path) in an autonomous.Makes the follower at INIT, from the robot's devices (after its drive and odometry are set up).
A path that another library drives (Pedro Pathing, through the pedro module), as one autonomous
step:
AutoRoutine.followPath(java.lang.String, com.crossbotics.ftchelper.auto.PathJob, double).A PID controller: it works out how much power to give so a value reaches a target.
The four PID gains of one controller as
Tunables, in one line.Odometry from a goBILDA Pinpoint: a small computer on an I2C port that reads two odometry pods and its
own IMU and works out the pose itself, about 1500 times a second.
Passes the robot's last pose from Autonomous to TeleOp.
Where the robot is on the field, from odometry: small wheels ("pods") or a sensor that measure how
far the robot moved.
Any servo with named positions: a deploy servo, a fold-out pivot, a gate, a flag.
A motor that moves something to named positions and holds it there: a lift, an arm, a slide,
a motor-driven claw.
A normal (positional) servo with named positions: a claw, a wrist, a hood, a gate.
Practice or competition.
A "drive backwards" mode: when ON, forward and strafe are flipped, so the back of the
robot acts as the front.
The robot's drivetrain described ONCE: motor names and directions, autonomous tuning, and how the
Control Hub is mounted.
What is on the robot, written once in the team's
Robot.java: the drive and one line per
mechanism, with each part's name in the robot configuration.Telemetry with two levels: STANDARD lines for the drivers, DEBUG lines for programmers.
A motor that cannot be driven past its safe range.
A feeder driven by a servo (a kicker or pusher arm): push, wait, come back, wait.
Finds a servo's numbers: its safe ends (limits) and the positions you want (open, closed, ...).
Sets up a servo in one readable chain.
A small settings file on the Control Hub, so choices and tuned numbers survive a restart.
How a part looks and where it sits, for the simulator's 3D view and its size checks: written in
Robot.java next to the part, so the simulator robot file comes from the code
(./gradlew :sim:fromRobot).The good shots saved in the shot tuner: distance, speed and (if there is a hood) hood angle.
Turns a distance into a shot: flywheel RPM and hood angle.
One shot setting: at
distance (inches), spin to rpm with the hood at
hoodDeg degrees.Builds the shot table: the flywheel speed (and hood angle) for each distance.
Stops a value from changing too fast.
The rule that keeps a mechanism inside its safe range.
A motor that spins: an intake, a roller, a conveyor, a spinner.
What it is doing.
A continuous-rotation servo (it spins like a small motor): a roller, a spinner, a small intake.
Tells when a move is stuck: the distance left has not gone down enough for a while.
The steps of one autonomous, read top to bottom (see
Auto).Helpers that make sticks and triggers feel good to drive with.
One part of the robot (a lift, a claw, an intake, a launcher) that needs a little work every loop.
A group of
Subsystems that are updated, stopped and shown together.A group of AprilTags in a row that mark one target (BIOBUZZ: the 4 tags under each CELL), so a camera
can report the GROUP as one target with one aiming point, even when it sees only some of the tags.
Drives a standard (tank / differential) chassis with 2 or 4 motors.
One target the camera sees, in the same form for every camera (webcam or Limelight).
A camera that finds targets.
Shortcuts for clear, same-every-time Driver Station telemetry.
Buzzes the gamepad to confirm a toggle, so the driver knows without looking:
two buzzes = ON, one buzz = OFF.
A number you can change while the robot runs, from the gamepad (
TuningMenu),
without rebuilding.A menu on the Driver Station to change
Tunable numbers with a gamepad, while the robot runs.A turret: turns to an angle in degrees, never past its limits (so cables never wind up),
and can hold a FIELD direction while the robot drives and turns.
A turret on one motor that turns inside its limits, by hand or following the goal with a
Camera.AprilTags with a USB webcam, using the FTC SDK's own AprilTag finder (SDK 12: single tags and
tag "clusters", groups of tags with one aiming point).
A wrist on one servo, with named angles (raw servo positions).