All Classes and Interfaces
Class
Description
Base for fake devices: supplies the boilerplate
HardwareDevice metadata so concrete fakes
(e.g.Where every AprilTag on a field is: tag id to its centre, the way it faces, and its size.
Collects tags for an
AprilTagLayout.One AprilTag: its id, the centre of its square, the direction its printed face looks, and the edge
length of the square whose corners a detector reports.
A robot's moving parts as a tree of joints, turned into the
Pose3d[] AdvantageScope's 3D Field tab
draws as Component (Robot) objects.Builds an
ArticulatedRobotModel one component at a time, parents before children.What kind of joint attaches a component to its parent.
A compartment of a
KinematicBody that game pieces can come to rest in and be counted in: a box in the
body's own frame.A camera's intrinsics: focal lengths and principal point in pixels, the image size, and optionally a lens
distortion model.
Where a camera sits on the robot and which way it points: the extrinsics.
The solid things a camera cannot see through, in two frames: boxes fixed to the field (structures,
walls, goals) and boxes fixed to the robot (its own chassis, a raised arm, a bumper).
One game piece as a
SimCamera sees it this tick: where its centre lands in the image, how big
it looks, how far away it is, and what it is.What a colour sensor's photodiodes measure: one raw count per channel, the numbers the chip puts in its
light-sensor data registers before any driver arithmetic.
Binds a colour sensor to the simulated field: finds the game piece in front of a
SensorMount and
makes a FakeRevColorSensorV3 see that piece's colour at that piece's distance.What the probe found: a piece and how far its surface is, or nothing.
Binds a touch sensor or limit switch to the simulated field: the switch's actuator is a small rectangle
bolted to the robot, and it is pressed while that rectangle touches the perimeter wall, an
ObstacleBox, or a game piece that is not held.What the actuator is touching.
Season-glue interface: the two numbers that describe a degree of freedom which never runs out of
travel — a continuous-rotation ejector servo, an intake roller, a flywheel.
A solid convex polyhedron a ball can rest on, roll along and bounce off: a convex hull given as its corner
points and its triangles.
Season-glue interface: drivetrain geometry + motor-model + field-bound constants the core
plant needs, supplied by the season layer in
TeamCode.The seven starter envelope terms from
docs/process/scorer-interface.md §3, sorted carefully into
the ones a run's log can actually answer and the ones it cannot.Fake
AnalogInput returning a settable voltage, so the unchanged SolversLib
AbsoluteAnalogEncoder wrapper (which reads getVoltage() / getMaxVoltage())
resolves headless.Fake
CRServo: a continuous-rotation servo, the kind of actuator that spins a roller or a wheel
for as long as it is told to.A simulated hardware device with a kinematic plant.
Fake
DigitalChannel: the one digital IO pin on a REV hub that a beam-break sensor, a limit
switch or a signal LED is wired to.Fake
DistanceSensor modelled on the REV 2m Distance Sensor (a VL53L0X time-of-flight chip).Fake external encoder: the plant → sensor → subsystem seam for a 1-DOF mechanism.
Headless fake of the goBILDA Pinpoint odometry computer, for SimLoop users whose robots use one.
JVM-constructible
HardwareMap that resolves fake devices by config name.Fake
I2cDeviceSynchSimple (the I2C bus client) that an I2cDeviceSynchDevice subclass
holds as its deviceClient.Fake of the SDK's universal
IMU — the interface a team gets back from
hardwareMap.get(IMU.class, "imu") on a Control Hub or Expansion Hub — driven by the drive plant's
heading.A Limelight 3A for the sim: the SDK 12.0
Limelight3A, looked up with
hardwareMap.get(Limelight3A.class, "limelight"), that sees AprilTags from a team-supplied
AprilTagLayout instead of over USB.Configures a
FakeLimelight3A.First-order drive-motor plant, seeded from PsiKit's test
FakeMotor, behind the REV hub's motor
controller.Headless fake of the REV Color Sensor V3.
Kinematic fake
Servo: a commanded position is held instantly (a bare servo has no dynamics
worth modelling for the drivetrain sim — mechanism dynamics live in Mechanism1DofPlant).Headless fake of the SparkFun Qwiic Optical Tracking Odometry Sensor (OTOS), for SimLoop users whose robots
use one.
The single, advanceable simulation clock (fakehardware-plant §6, domain R5).
Fake
TouchSensor: a REV Touch Sensor (or any button the robot configuration calls a "REV Touch
Sensor") that the sim presses and releases.Fake
VoltageSensor returning a fixed nominal battery voltage (default 12 V).The one and only place the localizer ↔ field frame rotation is written.
Everything fixed about the field that a game piece can touch: the perimeter wall, the solid
obstacles, the goals, the rigid structures
pieces collide with and rest in, the robot's own footprint, and the
physics numbers.One named setter per fact.
Fits a first-order velocity plant - the model SimLoop's
FakeMotor and drivetrain already step -
to a logged record of applied power and measured velocity, by least squares.A first-order plant: what the fit produces, and what the sim's own parameters describe.
What one fit found, and how well.
A logged record for one axis: time, the power applied, the velocity measured, and the battery.
Whether the robot's rectangular footprint overlaps a field structure, and the shortest move that would
take it back out.
The shortest move that takes the footprint out of one box.
The flat colours and the one light a
SimFrameRenderer paints a scene with.Collects a
FrameStyle.Runs a scenario for as long as a
GamepadInputSource has input, and hands each tick's gamepads to
the scenario body.Where a session's gamepad input comes from, one loop at a time: a person at a keyboard
(
KeyboardGamepadSource), a recorded track (GamepadInputTrack.replay()), or a test's
script.A recorded driving session: what both gamepads read on every sim loop, one plain-text line per loop.
Both gamepads on one loop.
Writes a track one line at a time, flushing after every line, so a session that ends abruptly - the
window closed, the process killed - still leaves every loop it ran on disk.
What the drivers do with their gamepads, tick by tick.
Everything one FTC gamepad reports on one loop, as a plain value: which buttons are down and where
every stick, trigger and touchpad finger is.
One game piece in the sim: a ball of some kind, at a field position in inches, moving at some velocity,
in exactly one
PossessionState.The numbers that govern how loose and in-flight game pieces move: gravity, how bouncy each kind of
contact is, how quickly a rolling piece slows down, and how finely a sim tick is sub-stepped.
Builder with one named setter per number, each documented with its default's provenance.
The one place a game piece changes hands or moves.
The sim-versus-real gap report: for each fitted quantity, what the real log says, what the sim's own
parameters say, and how far apart they are, written as one markdown page beside the RLOG it came from.
One fitted quantity: a drivetrain axis, a flywheel, anything that is a first-order velocity plant.
The acceptance gate: the one place that decides whether a candidate run is allowed to become the new
last-best (`docs/process/scorer-interface.md` §6).
The four §6 clauses, in the order a verdict reports them.
One clause's outcome plus the sentence explaining it, for the verdict a human reads.
A fact the gate is told rather than measures.
What the caller knows about the current last-best score.
How one clause came out.
The two facts that are not in any log: whether the tests passed, and whether an independent review
approved the change.
The gate's answer: accepted or not, plus every clause and why.
One safety-envelope term: something that must stay true no matter how good the objective gets
(
docs/process/scorer-interface.md §3).What a guardrail concluded about one run.
A guardrail's conclusion about one run: a status, a penalty, and why.
What makes a
KinematicBody a dynamic hinged body: one degree of freedom, its angle about the
body's fixed axis, moved by gravity on its own mass and by every contact the game pieces make with it.One segment of a mechanism, as it should be drawn in AdvantageScope.
Which of a segment's two drawn numbers this joint moves.
How many bytes each JVM instruction takes (JVMS §6.5), for code that walks a method's bytecode one
instruction at a time.
A person at a keyboard, standing in for an FTC gamepad.
One key's effect on the gamepad it is driving.
Something that can report which keys are held down right now.
A rigid structure that game pieces collide with and can rest in, and that may turn about one fixed axis: a
goal that tips, a flap, or a fixed frame that never moves.
Linear least squares, written out: find the
x that makes A x as close as possible to
b, in the sense of the smallest sum of squared differences.The answer to one least-squares problem.
One telescoping stage of a linear mechanism — a segment whose drawn length moves while its angle
stays put.
The bookkeeping half of the loop: scores each candidate run with its one fixed
Scorer, judges
it with Gate, holds the last-best, emits a Milestone when the answer gets qualitatively
better, and writes the StopReport (docs/process/scorer-interface.md §5, §6, §8).One accepted run, with the score this driver gave it, the two facts the gate cannot measure, and the
candidate's own account of what it changed.
What the loop did with one offered run.
Closes the sim odometry loop for a mecanum drivetrain: each tick it reads the four drive
FakeMotors' modelled wheel velocities and integrates the pose through
MecanumPoseIntegrator.Kinematic mecanum forward-kinematics pose integrator.
Generic 1-DOF mechanism plant: the season-agnostic primitive every mechanism (slide, arm, turret) is
built on — one class, one config per mechanism.
Season-glue interface: the parameterized first-order dynamics + end-limits of one 1-DOF mechanism,
supplied by the season layer in
TeamCode.Draws a
MechanismSketchDefinition into AdvantageScope's Mechanism tab: it owns a PsiKit
LoggedMechanism2d, keeps one ligament per joint, and updates them as the mechanism moves.The complete description of one mechanism as AdvantageScope should draw it: a canvas, a mount point, and
an ordered chain of telescoping stages.
Step-by-step builder for a
MechanismSketchDefinition.One milestone: a point where the loop's best answer got qualitatively better, and the side-by-side
evidence for saying so (
docs/process/scorer-interface.md §5).Why a milestone was emitted.
How one subsystem with several real degrees of freedom is simulated: one plant per degree of
freedom, held side by side, ticked together and logged apart.
Collects the degrees of freedom, in the order they are added.
What the loop is trying to make better, declared up front
(
docs/process/scorer-interface.md §2).The human's rough estimate of what this objective is worth spending.
Which way a raw metric points.
Thrown when an objective's metric measured
NaN or an infinity.A fixed, solid, axis-aligned box on the field that game pieces bounce off: a goal structure's frame, a
flower's foot, a wall segment.
The surface shared by every plant in this package that models exactly one degree of freedom:
Mechanism1DofPlant (power-driven, through a motor or a continuous-rotation servo) and
PositionalServoPlant (command-driven, through a positional servo).An OpMode run could not be completed: the OpMode's own code threw, or it stopped cooperating with the
sim (it ran without ever reaching a lifecycle check, or it did not return after STOP).
Where an
OpModeRunner run is in the Driver Station's INIT / PLAY / STOP sequence.Runs a team's own OpMode, unchanged, against fake hardware: an iterative
OpMode or a
LinearOpMode, headless, one fixed sim tick at a time, and deterministically.What an
OpModeRunner run did, for a test to assert on.A solid box that may be turned any way: a centre, three perpendicular unit axes and a half extent along each.
1-DOF mechanism plant for a joint driven by a positional servo — the servo-side twin of
Mechanism1DofPlant.Season-glue interface: everything a
PositionalServoPlant needs to turn a servo command in
[0, 1] into a real mechanism position that takes time to get there.The complete, fixed set of possession states one game piece can be in.
Binds a distance sensor to the simulated field: casts one straight ray from a
SensorMount on the
robot and reports the first thing it hits - the perimeter wall, an ObstacleBox, a game piece that
is not held, or the floor.What a
RangeFinder ray hit first, and how far along the ray it was.What sort of thing stopped the ray.
Slows a sim run down to real time, so a person can drive it.
How the pacer waits.
Passes another source's frames through unchanged and writes each one to a track as it goes.
A
Telemetry that keeps what the Driver Station would have shown, so a test can read it back.One pivot of a mechanism — a segment of fixed length whose drawn angle moves.
A rigid transform in 3D: a rotation and then a translation, the pose of one frame expressed in another.
Compares two RLOG files by decoded field value, not raw bytes (BACKLOG B3,
docs/process/scorer-interface.md §2/§7).One decoded-field mismatch between two runs;
frameIndex is -1 for a frame-count mismatch.The numeric columns of an RLOG, with each frame's time: what a fit reads.
One part of a robot touching one thing on the field: which part, which structure, how deep, and the shortest
horizontal move of the robot that would take that part back out.
A point on the floor plane in the robot frame: how far ahead of the robot's centre and how far to its
left, in inches.
The robot as a compound of solid
boxes in its own frame: a few for the chassis, a few for
each mechanism, posed for the mechanisms' current positions.An immutable 3-D vector in the robot frame:
+X robot-forward (out the nose), +Y
robot-left, +Z up, with the origin at the centre of the drivetrain footprint at floor level.One finished sim run, read back off disk so it can be scored.
Thrown when a metric names a key the run never logged.
Thrown when a metric's logged value is not a number.
Runs one headless sim scenario end-to-end: owns the entire PsiKit lifecycle (sim-harness §2-3) and the
fixed-timestep tick loop, so a test does not hand-write it (BACKLOG "scenario runner" / area B).
One scenario's per-tick behavior: command the robot, advance its fake hardware/plants, log fields.
Decides, before each tick, whether that tick runs.
Runs after each tick has been logged, and may make the run wait.
Turns a finished run into one number, plus the breakdown that number came from
(
docs/process/scorer-interface.md §1, §8).One run's score: the total, and every term that produced it.
A region of the field that an in-flight game piece scores by entering: the mouth of a goal.
One named setter per fact;
ScoringVolume.Builder.box(double, double, double, double, double, double) and ScoringVolume.Builder.restPoint(double, double, double) are mandatory.A seeded random-number generator for anything on the field that is random on a real field and must
still replay identically in the sim: where the contents of a tipped goal land, for example.
Where a sensor sits on the robot and which way it looks.
An immutable 3-D polyline for one shot: the path a game piece took, or was meant to take, from the
launcher to wherever it stopped.
Where a game piece leaves the launcher, and how fast: a position plus a speed along a direction.
Logs the last few shots as intended-vs-actual arc pairs, in a shape AdvantageScope's 3D Field can draw
without any setup beyond adding the keys.
A camera on the robot that "sees" game pieces: given every piece's true position and the robot's pose, it
works out which pieces fall inside its image and where, as
CameraSightings.The FTC SDK's
ElapsedTime, reading the sim clock of the SimClockLoader that defined it.What a team's rewritten clock calls call instead.
A class loader that loads a team's classes with their clock calls moved onto one sim clock, so code that
uses
ElapsedTime, System.nanoTime(), Thread.sleep, TimeUnit.sleep,
Android's SystemClock or a computed sleep(ms) runs unchanged in a SimLoop test.What a rewritten wait (
Thread.sleep, LinearOpMode.sleep, idle()) asks of the
OpMode run that owns a SimClockLoader's clock.An FTC SDK
ElapsedTime that reads the simulation clock (FakeTimer) instead of the wall
clock.One synthetic camera frame from a
SimFrameRenderer: 8-bit RGB pixels, plus a label per pixel
saying which piece or tag it shows.Draws what a
CameraLens on a CameraMount would see, as a SimFrame of RGB pixels,
so a team's real pixel pipeline (an OpenCV VisionProcessor, a colour-blob detector, a contour
splitter) can run unchanged on frames from the sim.Configures a
SimFrameRenderer.Season-glue interface: the device registry the core needs to build a
FakeHardwareMap
that mirrors the real robot configuration.A camera on the robot that "sees" AprilTags: given a team-supplied
AprilTagLayout and the robot's
pose, it works out which tags a detector would find and where, as TagSightings.Why a tag is or is not seen; see the class comment for the order these are checked in.
A robot that stands still: an alliance partner parked for a whole period, or a no-show's empty spot made
solid.
What the loop says when it is stopped: the best answer it found, and proof that the answer reproduces.
How the second run of the best candidate's scenario came out.
Runs one accepted candidate's scenario again, from the top, and returns the fresh RLOG.
How a switch is wired to a digital pin: which line level means "pressed".
One AprilTag as a
SimTagCamera sees it this tick: the ground truth a tag detector would have to
recover, with no noise.A rectangular region bolted to the robot that decides whether a game piece is close enough to be
acquired — the "mouth" of an intake, expressed as geometry instead of roller-on-ball contact.
Draws a
TurretSketchDefinition in AdvantageScope's 3D Field tab: a turret that yaws on the
robot, the chain riding on it (a hood), and a cone at the chain's tip pointing along the shot.A mechanism whose base joint is a turret: a pivot that yaws about a vertical axis, carrying a planar
chain (a hood, an arm, a slide) that swings round with it.
Step-by-step builder.