Season · 2025–2026

DECODE

An artifact-launching game, robots intake and shoot artifacts into a goal, scoring from near and far zones with autonomous and dynamic aiming.

🏆 Control Award · Winner

↓ the journey

The mission

Autonomous as the equalizer

Our first season. As a solo team working out of a home design lab, I designed and built a turret-aimed artifact shooter from scratch, iterating from a Meet 0 prototype (V0) through to the current V2, on top of RFrame, a custom Java software stack, with a scratch-built autonomous that scores 10–12 artifacts. It earned the Control Award.

As a solo team, hardware and driving are at a disadvantage against larger crews, so a consistent, high-scoring autonomous became the competitive advantage everything else was built to serve.

🏆 Winner

Control Award

The Control Award recognizes a team that uses sensors and software to enhance the robot's functioning, a fitting match for our continuous turret auto-aiming, OTOS-based localization, and a scratch-built autonomous routine.

The machines

Three builds, one season

DECODE Bot V0

The Meet 0 prototype, proving out the shooter and odometry.

DECODE Bot V1

Added the turret and spindexer, and upgraded localization.

DECODE Bot V2

The current build, rebuilt rigid for consistency, turret-aimed and autonomous-first.

⚖️ Strategy tradeoff

V2 dropped the indexer and color sensors, giving up ball sorting, a calculated risk, traded for faster intake cycles and an autonomous tuned purely for scoring speed and consistency.

Design close-up

How it's built

Shooter

Type: Hooded flywheel + turret
Flywheel speed: 6000 RPM
Flywheel weight: 5 lb
Turret drive: Belt driven

Drivetrain

Type: Mecanum
Speed: 1.7 m/s
Motor torque: 24.3 kg·cm

Intake

Type: Rubber band
Speed: 600 RPM
Cycle: Single-stage, fast

The math

Dynamic aiming

Scoring from anywhere means the turret, flywheel, and hood all solve for the current shot in real time, which only works because the robot always knows where it is on the field.

Turret aiming angle

t_{a}=\tan^{-1}\!\left(\frac{d_y}{d_x}\right)-90^{\circ}-a

where d_x, d_y are the displacement to the goal and ais the robot's current heading. The turret recomputes this every loop, so it keeps tracking the goal regardless of how the robot is turned, in both autonomous and TeleOp.

Flywheel & hood control

As the distance to the goal changes, the flywheel motor speed ramps up or down and the hood servo adjusts the launch angle, both driven by distance-calibrated models. The result: reliable shots from anywhere on the field with no manual tuning between shots.

Programming

Built on RFrame

The stack is Java on the FTC SDK, running on top of RFrame , a custom framework I built from scratch. It handles hardware initialization, background threading, odometry management, and subsystem coordination, so each season starts from a clean foundation instead of boilerplate. It's open-sourced for any team to use.

The architecture is modular: drive control, mechanism control, and autonomous logic are independent subsystems. Autonomous routines can change without touching TeleOp, and each mechanism is tuned on its own, which is what made the V0 → V2 iteration so fast.

Localization

Knowing where you are

Accurate aiming and autonomous both depend on the robot knowing its exact position. Getting there took three iterations, and one mechanical lesson.

OTOS + webcam AprilTags

A SparkFun OTOS optical sensor gave smooth short-term tracking, but error accumulated into measurable drift. A webcam + AprilTag correction helped, but stayed slow and imprecise.

OTOS + Limelight (multi-tag)

Switching to a Limelight greatly improved AprilTag accuracy. Lighting still caused inconsistent poses, so I fused multi-tag detection with OTOS, though 1–2 in. pose shifts still slipped through.

OTOS in auto + driver re-sync

The big discovery: the 1/8" plywood base was flexing and warping the frame, corrupting OTOS. A 9-gauge aluminum base fixed it. OTOS now runs solo in autonomous; TeleOp re-syncs to vision only when the robot is stationary, driver-controlled.

The lesson: sensor accuracy isn't only a software problem, it depends on mechanical rigidity.

Autonomous

A pathing system from scratch

PedroPathing, the popular FTC path-follower, wouldn't integrate with RFrame, so I built a pathing system from scratch, designed specifically for the framework and the robot. Combined with OTOS localization, it runs 12-artifact routines where turret aiming, flywheel, intake, and pathing all stay in sync. The target: >99% consistency.

The journey