VEX Robotics

State Champions.
Building, programming, and CAD design.

I've done VEX Robotics for four years: from struggling to understand PID and having no design experience to coding autonomous programs that won the California State Championship and building robots that competed at the World Championship.

Design

CAD Models

I learned how to use CAD in the 22-23 season, and I haven't stopped designing robots with CAD since. I primarily use OnShape, although I have experience with Fusion 360 and Inventor as well.

Spin Up (2022–23)

Spin Up (2022–23) v2

Over Under (2023–24)

Over Under (2023–24) v2

Over Under (2023–24) v3

Spin Up (2022–23) v1

My first V5RC robot design, which included some innovative (but not entirely practical) features:

U-Shaped flywheel design with an adjustable hood to change shot angle
Tether wall mechanism to block off opponents in the corners during the expansion period
257 RPM drivebase with 4" wheels
Three tracking wheels with rotation sensors for implementing odometry

Spin Up (2022–23) v2

My second Spin Up robot design, which was built and used in competitions during the season:

Same-side flywheel mechanism, inspired by team 4082B's early season robot
600 RPM intake and indexing mechanism — using a storage chamber to hold and index disks
Pneumatic expansion mechanism — shoots string to cover the entire field
360 RPM drivebase with 3.25" wheels

Over Under (2023–24) v1

A highly experimental early-season design for the Over Under season:

Slingshot shooting mechanism — using a shaft decoupler system to allow for variable slingshot windup and power
600 RPM flex wheel intake, which can lift using pneumatic pistons
Short robot design to traverse easily under the low bars
343 RPM drivebase with 4" wheels — allowing for smooth barrier crossing with sleds

Over Under (2023–24) v2

Mid-season robot design featuring unique innovations to the standard catapult design:

38 RPM catapult with a double-etched slip gear, enabling the fast loading of triballs
Custom-made catapult basket using a lightweight bent axle — fitting to the irregular shape of triballs
Pneumatic-powered wings for pushing triballs in the goal efficiently
450 RPM drivebase with 2.75" wheels — using four wheels per side for optimal barrier crossing

Over Under (2023–24) v3

Another mid-season robot designed in response to changing game strategies — featuring an elevated flywheel mechanism to counter blocker mechanisms:

6-bar lift using askew geometry to maximize height — reaches around 36"
Flywheel mechanism for fast triball loading
Passive intake mechanism using ratchet to pick up and store triballs
450 RPM drivebase with 2.75" wheels — using four wheels per side for optimal barrier crossing

left-click to rotate scroll to zoom middle-click to pan

Fetching robot assembly…

Front

Back

Left

Right

Top

Bottom

Programming

C++ Control Systems

I independently learned and implemented key control theory algorithms over four years, starting with a malfunctioning time-based autonomous program. I stepped into the world of control theory in pursuit of perfecting robotic movement: days tuning PID controllers turned into weeks crafting odometry and MCL.

PID Controller

Proportional-Integral-Derivative control for precise motor movements. Spent weeks tuning constants for consistent autonomous performance across different match conditions.

Odometry

Global position tracking using unpowered tracking wheels. When I first implemented it, the rotation sensor recorded the wrong position — thorough debugging revealed the tracking wheel was slipping, not a software bug.

Monte Carlo Localization

Probabilistic localization: the robot's possible position is modeled as random particles, iteratively filtered using sensor data — the same probabilistic sampling technique used in orbital determination and many other estimation problems.

View on GitHub

odometry.cpp C++

// Odometry: track robot position from wheel encoders
void updateOdometry() {
  double dL = leftTracker.get_value();
  double dR = rightTracker.get_value();
  double dB = backTracker.get_value();

  double dTheta = (dL - dR) / TRACK_WIDTH;

  if (fabs(dTheta) < 1e-6) {
    // Straight-line motion
    globalX += dB * cos(heading);
    globalY += dB * sin(heading);
  } else {
    // Arc motion — integrate curvature
    double r = dB / dTheta;
    globalX += r * (sin(heading + dTheta)
                  - sin(heading));
    globalY -= r * (cos(heading + dTheta)
                  - cos(heading));
    heading += dTheta;
  }
}

mcl.cpp Monte Carlo Localization

// Resample particles weighted by sensor likelihood
void resampleParticles(
    vector<Particle>& particles,
    double sensorReading
) {
  // Weight each particle by Gaussian likelihood
  for (auto& p : particles) {
    double expected = predictedSensor(p.x, p.y);
    p.weight = gaussianLikelihood(
        sensorReading, expected, SIGMA
    );
  }
  normalizeWeights(particles);
  // Low-variance resampling
  particles = lowVarianceSampler(particles);
}

// Gaussian likelihood function
double gaussianLikelihood(
    double z, double mu, double sigma
) {
  double diff = z - mu;
  return exp(-(diff*diff) / (2*sigma*sigma));
}