VEX Robotics Class Project

Project Overview

For our final project in Stuyvesant's Intro to Robotics course, my team of three built a VEX robot for a class competition where robots competed to collect balls, place them onto pegs, and navigate different parts of the game field, including teeter totters.

Our team selected the chassis, wheels, mechanisms, sensors, and other components we wanted to use. We divided the work based on our strengths. My teammates focused primarily on the physical construction and operation of the robot, while I took responsibility for most of the programming.

Project

Intro to Robotics Final Project

Team

3 Students

My Role

Programming & Sensor Logic

Platform

VEX V5 / C++

Robot & Team Design

The physical robot was a team effort. We built it around an arm and hook mechanism for collecting balls and placing them onto pegs while still allowing the robot to move around the game field.

My teammates handled most of the mechanical construction. I helped with smaller assembly tasks such as mounting wheels and components, and I also worked with the team to improve the hook design as the robot developed.

Earlier Build

Earlier versions of the robot before the final hook and mechanism revisions.

Earlier version of our VEX robot from an angled front view

Earlier version of our VEX robot showing the arm and gearing

Final Build

The later version of the robot with the revised 3D printed hook and updated mechanism.

Final version of our VEX robot with the revised hook

Final version of our VEX robot from another angle

My Contribution

Since I had the most programming experience on the team, I was responsible for writing the robot's control and autonomous code. I programmed the drivetrain, arm controls, sensor logic, and autonomous sequence.

Driver Controls

I programmed the joystick-based drivetrain controls. The forward and turning inputs from the controller are combined to calculate separate speeds for the left and right sides of the robot.

drivetrain.cpp - code snippet

int forwardSpeed = Controller1.Axis3.position();
int turnSpeed = Controller1.Axis1.position();

LeftDriveSmart.spin(
    forward,
    forwardSpeed + turnSpeed,
    percent
);

RightDriveSmart.spin(
    forward,
    forwardSpeed - turnSpeed,
    percent
);

Autonomous Programming

I wrote a sequence based autonomous mode that used a potentiometer to monitor the angle of the arm.

This allowed the robot to raise or lower the arm to specific positions before continuing through the next movement in the sequence.

autonomous.cpp - sequence logic - code snippet

int sequence = 0;
bool runRoutine = true;

while (runRoutine) {

  if (sequence == 0) {
    if (PotentiometerE.angle(degrees) < 120) {
      ArmMotor.spin(forward);
    } else {
      ArmMotor.stop(hold);
      sequence = 1;
    }
  }

  else if (sequence == 1) {
    Drivetrain.driveFor(forward, 1450, mm);
    sequence = 2;
  }

  else if (sequence == 2) {
    Drivetrain.turnFor(right, 80, degrees);
    sequence = 3;
  }

  else if (sequence == 3) {
    Drivetrain.driveFor(forward, 500, mm);
    sequence = 4;
  }

  else if (sequence == 4) {
    if (PotentiometerE.angle(degrees) > 60) {
      ArmMotor.spin(reverse);
    } else {
      ArmMotor.stop(hold);
      sequence = 5;
    }
  }

  else if (sequence == 5) {
    Drivetrain.driveFor(reverse, 200, mm);
    sequence = 6;
  }

  else if (sequence == 6) {
    Drivetrain.stop();
    ArmMotor.stop(hold);
    runRoutine = false;
  }
}

Autonomous Sequence

01 Arm to 120°

02 Forward 1450 mm

03 Turn Right 80°

04 Forward 500 mm

05 Arm to 60°

06 Reverse 200 mm

Autonomous Demo

The robot executing the autonomous mode programmed for our final project.

Sensor Development

During development, I tested several sensors to see how they could be used for automated behavior. This video shows some of that experimentation. Not every sensor shown was used in the final competition routine.

For the final autonomous mode, the potentiometer was used to monitor the position of the arm so the program could move it to specific angles.

This was one of my first experiences using sensor readings in code to control a robot.

What I Learned

This project was one of my first experiences seeing code and hardware operate simultaneously.

I learned how sensor readings could be used to automate movement, but I also learned that robots are much less predictable than code running by itself. Small differences in positioning, motor condition, assembly, and the game surface could change how the same autonomous mode behaved.

Debugging those differences taught me that programming a physical system requires thinking about both software and hardware.

If I rebuilt the robot, I would simplify the autonomous mode earlier. Instead of relying on several separate movements and turns, I would choose a starting position that reduces the number of actions required to complete the same task.

The project made me much more interested in robotics and sensors. Seeing code move a real object, respond to sensor input, and complete a physical task made me want to learn more about embedded systems, robotics, and the connection between hardware and software.