Commit

# Conflicts:
#	TeamCode/src/main/java/org/firstinspires/ftc/teamcode/DevTeleop.java

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/AsherOrientBlue.java

@@ -26,15 +26,15 @@ import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
  * @version 1.0, 3/12/2024
  */
 @Config
-@Autonomous(name = "AutoExampleTwo", group = "Autonomous Pathing Tuning")
-public class AutoExampleTwo extends OpMode {
+@Autonomous(name = "AsherOrientBlue", group = "Autonomous Pathing Tuning")
+public class AsherOrientBlue extends OpMode {
     private Telemetry telemetryA;
 
     private Follower follower;
 
     private PathChain path;
 
-    private final Pose startPose = new Pose(10.0, 40, 90);
+    private final Pose startPose = new Pose(9.757, 84.983, 90);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -49,30 +49,28 @@ public class AutoExampleTwo extends OpMode {
         follower.setStartingPose(startPose);
 
         path = follower.pathBuilder()
+                /*
+                * Only update this path
+                 */
                 .addPath(
                         // Line 1
                         new BezierLine(
-                                new Point(10.000, 40.000, Point.CARTESIAN),
-                                new Point(60.000, 40.000, Point.CARTESIAN)
+                                new Point(20.500, 7.800, Point.CARTESIAN),
+                                new Point(20.500, 87.500, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 2
                         new BezierLine(
-                                new Point(60.000, 40.000, Point.CARTESIAN),
-                                new Point(60.000, 25.000, Point.CARTESIAN)
-                        )
-                )
-                .setConstantHeadingInterpolation(Math.toRadians(90))
-                .addPath(
-                        // Line 3
-                        new BezierLine(
-                                new Point(60.000, 25.000, Point.CARTESIAN),
-                                new Point(10.000, 25.000, Point.CARTESIAN)
+                                new Point(20.500, 87.500, Point.CARTESIAN),
+                                new Point(7.800, 87.500, Point.CARTESIAN)
                         )
                 )
+
                 .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+                /*
+                * End of only update this path
+                 */
 
         follower.followPath(path);
 

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/AsherPathBlueV1.java

@@ -0,0 +1,133 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AsherPathBlueV1", group = "Autonomous Pathing Tuning")
+public class AsherPathBlueV1 extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(9.757, 84.983, 90);
+
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.4);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                /*
+                * Only update this path
+                 */
+                .addPath(
+                        // Line 1
+                        new BezierCurve(
+                                new Point(7.800, 87.5, Point.CARTESIAN),
+                                new Point(19.000, 116.000, Point.CARTESIAN),
+                                new Point(93.000, 118.000, Point.CARTESIAN),
+                                new Point(45.000, 115.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(45.000, 115.000, Point.CARTESIAN),
+                                new Point(14.000, 126.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 3
+                        new BezierCurve(
+                                new Point(14.000, 126.000, Point.CARTESIAN),
+                                new Point(43.000, 112.500, Point.CARTESIAN),
+                                new Point(64.000, 92.000, Point.CARTESIAN),
+                                new Point(77.000, 117.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(77.000, 117.000, Point.CARTESIAN),
+                                new Point(20.000, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 5
+                        new BezierCurve(
+                                new Point(20.000, 135.000, Point.CARTESIAN),
+                                new Point(113.000, 95.000, Point.CARTESIAN),
+                                new Point(69.000, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(69.000, 135.000, Point.CARTESIAN),
+                                new Point(20.500, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 7
+                        new BezierCurve(
+                                new Point(20.500, 135.000, Point.CARTESIAN),
+                                new Point(101.500, 95.500, Point.CARTESIAN),
+                                new Point(72.500, 95.500, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+                /*
+                * End of only update this path
+                 */
+
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/BluenbAutov1.java

@@ -1,4 +0,0 @@
-package org.firstinspires.ftc.teamcode;
-
-public class BluenbAutov1 {
-}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/CometBotAuto.java

@@ -0,0 +1,35 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.runmodes.Auto;
+
+
+@Autonomous(name = "CometBot Auto", group = "Debug")
+public class CometBotAuto extends OpMode {
+    public Auto auto;
+
+    @Override
+    public void init() {
+        auto = new Auto(hardwareMap, telemetry, new Follower(hardwareMap));
+    }
+
+    @Override
+    public void start() {
+        auto.start();
+    }
+
+    @Override
+    public void loop() {
+        auto.update();
+        telemetry.addData("Arm State", auto.arm.getState());
+        telemetry.addData("Arm Position", auto.arm.getPosition());
+        telemetry.addData("Claw State", auto.claw.getState());
+        telemetry.addData("Wrist State", auto.wrist.getState());
+        telemetry.addData("Wrist Position", auto.wrist.getPosition());
+        telemetry.update();
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/CometBotDrive.java

@@ -0,0 +1,31 @@
+package org.firstinspires.ftc.teamcode;
+
+import static org.firstinspires.ftc.teamcode.util.action.FieldConstants.blueBucketStartPose;
+
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.runmodes.Teleop;
+
+@TeleOp(name="ComeBot Drive", group="Debug")
+@Disabled
+public class CometBotDrive extends OpMode {
+
+    private Teleop teleop;
+
+    @Override
+    public void init() {
+        teleop = new Teleop(hardwareMap,
+                telemetry,
+                new Follower(hardwareMap),
+                gamepad1);
+        teleop.start();
+    }
+
+    @Override
+    public void loop() {
+        teleop.update();
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/DevTeleOpRemix.java

@@ -0,0 +1,97 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+
+import org.firstinspires.ftc.teamcode.subsystem.ArmSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.LiftSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.MotorsSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.WristSubsystem;
+
+@TeleOp(name = "Dev Teleop Remix", group = "Debug")
+@Disabled
+public class DevTeleOpRemix extends OpMode {
+
+    public ClawSubsystem claw;
+    public ArmSubsystem arm;
+    public WristSubsystem wrist;
+    public LiftSubsystem lift;
+    public MotorsSubsystem motors;
+
+    public Gamepad currentGamepad1;
+    public Gamepad previousGamepad1;
+    public Gamepad currentGamepad2;
+    public Gamepad previousGamepad2;
+
+    public double power = .6;
+
+    @Override
+    public void init() {
+
+        claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.CLOSED);
+        arm = new ArmSubsystem(hardwareMap, ArmSubsystem.ArmState.PARK);
+        wrist = new WristSubsystem(hardwareMap, WristSubsystem.WristState.FLOOR);
+        lift = new LiftSubsystem(hardwareMap);
+        motors = new MotorsSubsystem(hardwareMap, telemetry, power);
+
+        claw.init();
+        arm.init();
+        wrist.init();
+        lift.init();
+        motors.init();
+
+        currentGamepad1 = new Gamepad();
+        previousGamepad1 = new Gamepad();
+        currentGamepad2 = new Gamepad();
+        previousGamepad2 = new Gamepad();
+    }
+
+    public void theDrop(ArmSubsystem arm, WristSubsystem wrist) {
+        if (currentGamepad1.a && !previousGamepad1.a) {
+            wrist.floorWrist();
+            arm.engageArm();
+        }
+    }
+
+    public void thePickup(ClawSubsystem claw) {
+        if (currentGamepad1.x && !previousGamepad1.x) {
+            claw.switchState();
+        }
+    }
+
+    public void theLift(ArmSubsystem arm, WristSubsystem wrist) {
+        if (currentGamepad1.b && !previousGamepad1.b) {
+            arm.parkArm();
+            wrist.bucketWrist();
+        }
+    }
+
+    public void theLowBucketScore(LiftSubsystem lift, WristSubsystem wrist, ArmSubsystem arm) {
+        if (currentGamepad1.y && !previousGamepad1.y) {
+            lift.toLowBucket();
+            wrist.bucketWrist();
+        }
+    }
+
+    @Override
+    public void loop() {
+
+        previousGamepad1.copy(currentGamepad1);
+        currentGamepad1.copy(gamepad1);
+
+        previousGamepad2.copy(currentGamepad2);
+        currentGamepad2.copy(gamepad2);
+
+        theDrop(arm, wrist);
+        thePickup(claw);
+        theLift(arm, wrist);
+        theLowBucketScore(lift, wrist, arm);
+
+        motors.calculateTrajectory(gamepad1);
+
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/DevTeleOpRemixDeux.java

@@ -0,0 +1,107 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.subsystem.ArmSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.LiftSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.MotorsSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.WristSubsystem;
+
+@TeleOp(name = "Dev Teleop Remix Deux", group = "Debug")
+@Disabled
+public class DevTeleOpRemixDeux extends OpMode {
+
+    private Follower follower;
+
+    public ClawSubsystem claw;
+    public ArmSubsystem arm;
+    public WristSubsystem wrist;
+    public LiftSubsystem lift;
+    public MotorsSubsystem motors;
+
+    public Gamepad currentGamepad1;
+    public Gamepad previousGamepad1;
+    public Gamepad currentGamepad2;
+    public Gamepad previousGamepad2;
+
+    public double power = .6;
+
+    @Override
+    public void init() {
+
+        follower = new Follower(hardwareMap);
+
+        claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.CLOSED);
+        arm = new ArmSubsystem(hardwareMap, ArmSubsystem.ArmState.PARK);
+        wrist = new WristSubsystem(hardwareMap, WristSubsystem.WristState.FLOOR);
+        motors = new MotorsSubsystem(hardwareMap, telemetry);
+        lift = new LiftSubsystem(hardwareMap);
+
+        claw.init();
+        arm.init();
+        wrist.init();
+        lift.init();
+        motors.init();
+
+        currentGamepad1 = new Gamepad();
+        previousGamepad1 = new Gamepad();
+        currentGamepad2 = new Gamepad();
+        previousGamepad2 = new Gamepad();
+
+        follower.setMaxPower(this.power);
+        follower.startTeleopDrive();
+
+    }
+
+    public void theDrop(ArmSubsystem arm, WristSubsystem wrist) {
+        if (currentGamepad1.a && !previousGamepad1.a) {
+            wrist.floorWrist();
+            arm.engageArm();
+        }
+    }
+
+    public void thePickup(ClawSubsystem claw) {
+        if (currentGamepad1.x && !previousGamepad1.x) {
+            claw.switchState();
+        }
+    }
+
+    public void theLift(ArmSubsystem arm, WristSubsystem wrist) {
+        if (currentGamepad1.b && !previousGamepad1.b) {
+            arm.parkArm();
+            wrist.bucketWrist();
+        }
+    }
+
+    public void theLowBucketScore(LiftSubsystem lift, WristSubsystem wrist, ArmSubsystem arm) {
+        if (currentGamepad1.y && !previousGamepad1.y) {
+            lift.toLowBucket();
+            wrist.bucketWrist();
+        }
+    }
+
+    @Override
+    public void loop() {
+
+        previousGamepad1.copy(currentGamepad1);
+        currentGamepad1.copy(gamepad1);
+
+        previousGamepad2.copy(currentGamepad2);
+        currentGamepad2.copy(gamepad2);
+
+        theDrop(arm, wrist);
+        thePickup(claw);
+        theLift(arm, wrist);
+        theLowBucketScore(lift, wrist, arm);
+
+        follower.setTeleOpMovementVectors(-gamepad1.left_stick_y, -gamepad1.left_stick_x, -gamepad1.right_stick_x);
+        follower.update();
+
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/DevTeleop.java

@@ -0,0 +1,196 @@
+package org.firstinspires.ftc.teamcode;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER_DIRECTION;
+
+import android.graphics.Point;
+
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.Gamepad;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+import org.firstinspires.ftc.teamcode.subsystem.ArmSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.LiftSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.WristSubsystem;
+
+@TeleOp(name = "Dev Teleop", group = "Debug")
+public class DevTeleop extends OpMode {
+
+    public ClawSubsystem claw;
+    public ArmSubsystem arm;
+    public WristSubsystem wrist;
+    public LiftSubsystem lift;
+    public Gamepad currentGamepad1;
+    public Gamepad previousGamepad1;
+    public Gamepad currentGamepad2;
+    public Gamepad previousGamepad2;
+    public DcMotor frontLeftMotor;
+    public DcMotor backLeftMotor;
+    public DcMotor frontRightMotor;
+    public DcMotor backRightMotor;
+
+    private double MAX_POWER = .45;
+    @Override
+    public void init() {
+        claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.CLOSED);
+        arm = new ArmSubsystem(hardwareMap, ArmSubsystem.ArmState.PARK);
+        wrist = new WristSubsystem(hardwareMap, WristSubsystem.WristState.FLOOR);
+        lift = new LiftSubsystem(hardwareMap);
+        claw.init();
+        arm.init();
+        wrist.init();
+        lift.init();
+
+        frontLeftMotor  = hardwareMap.get(DcMotor.class, FRONT_LEFT_MOTOR);
+        backLeftMotor  = hardwareMap.get(DcMotor.class, BACK_LEFT_MOTOR);
+        frontRightMotor = hardwareMap.get(DcMotor.class, FRONT_RIGHT_MOTOR);
+        backRightMotor = hardwareMap.get(DcMotor.class, BACK_RIGHT_MOTOR);
+
+        frontLeftMotor.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
+        backLeftMotor.setDirection(BACK_LEFT_MOTOR_DIRECTION);
+        frontRightMotor.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
+        backRightMotor.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+
+        currentGamepad1 = new Gamepad();
+        previousGamepad1 = new Gamepad();
+        currentGamepad2 = new Gamepad();
+        previousGamepad2 = new Gamepad();
+    }
+
+    public void theDrop(ArmSubsystem arm, WristSubsystem wrist) {
+//pick up
+        if (currentGamepad2.dpad_down && !previousGamepad2.dpad_down) {
+            wrist.floorWrist();
+            arm.engageArm();
+        }
+
+
+
+    }
+    public void thePickup(ClawSubsystem claw) {
+//claw open close
+        if (currentGamepad2.right_bumper && !previousGamepad2.right_bumper) {
+            claw.switchState();
+        }
+
+    }
+
+    /* public void theLift(ArmSubsystem arm, WristSubsystem wrist) {
+
+        if (currentGamepad1.b && !previousGamepad1.b) {
+            arm.parkArm();
+            wrist.bucketWrist();
+        }
+
+    }
+*/
+    public void theLowBucketScore(LiftSubsystem lift, WristSubsystem wrist, ArmSubsystem arm) {
+//low bucket
+        if (currentGamepad2.a && !previousGamepad2.a) {
+            lift.toLowBucket();
+            arm.bucketArm();
+            wrist.bucketWrist();
+        }
+    }
+
+    public void theHighBucketScore(LiftSubsystem lift, WristSubsystem wrist, ArmSubsystem arm) {
+//high basket
+        if (currentGamepad2.b && !previousGamepad2.b) {
+            lift.toHighBucket();
+            arm.bucketArm();
+            wrist.bucketWrist();
+        }
+    }
+
+    public void theTravel(LiftSubsystem lift, ArmSubsystem arm, WristSubsystem wrist){
+//
+        if (currentGamepad2.dpad_right && !previousGamepad2.dpad_right){
+            lift.toFloor();
+            arm.bucketArm();
+            wrist.floorWrist();
+        }
+    }
+
+    public void hoverState(ArmSubsystem arm, WristSubsystem wrist, LiftSubsystem lift){
+        if (currentGamepad1.dpad_left && !previousGamepad2.dpad_left){
+            lift.toHover();
+            wrist.floorWrist();
+            arm.engageArm();
+        }
+
+
+    }
+
+    @Override
+    public void loop() {
+        previousGamepad1.copy(currentGamepad1);
+        currentGamepad1.copy(gamepad1);
+        previousGamepad2.copy(currentGamepad2);
+        currentGamepad2.copy(gamepad2);
+
+
+        theDrop(arm, wrist);
+        thePickup(claw);
+       // theLift(arm, wrist);
+        theLowBucketScore(lift, wrist, arm);
+        theHighBucketScore(lift, wrist, arm);
+        theTravel(lift, arm, wrist);
+
+        double max;
+
+        // POV Mode uses left joystick to go forward & strafe, and right joystick to rotate.
+        double axial   = -gamepad1.left_stick_y;  // Note: pushing stick forward gives negative value
+        double lateral =  gamepad1.left_stick_x;
+        double yaw     =  gamepad1.right_stick_x;
+
+        // Combine the joystick requests for each axis-motion to determine each wheel's power.
+        // Set up a variable for each drive wheel to save the power level for telemetry.
+        double leftFrontPower  = axial + lateral + yaw;
+        double rightFrontPower = axial - lateral - yaw;
+        double leftBackPower   = axial - lateral + yaw;
+        double rightBackPower  = axial + lateral - yaw;
+
+        // Normalize the values so no wheel power exceeds 100%
+        // This ensures that the robot maintains the desired motion.
+        max = Math.max(Math.abs(leftFrontPower), Math.abs(rightFrontPower));
+        max = Math.max(max, Math.abs(leftBackPower));
+        max = Math.max(max, Math.abs(rightBackPower));
+
+        if (max > 1.0) {
+            leftFrontPower  /= max;
+            rightFrontPower /= max;
+            leftBackPower   /= max;
+            rightBackPower  /= max;
+        }
+
+
+        // Send calculated power to wheels
+        frontLeftMotor.setPower(leftFrontPower * MAX_POWER);
+        frontRightMotor.setPower(rightFrontPower * MAX_POWER);
+        backLeftMotor.setPower(leftBackPower * MAX_POWER);
+        backRightMotor.setPower(rightBackPower * MAX_POWER);
+
+        // Show the elapsed game time and wheel power.
+        telemetry.addData("Front left/Right", "%4.2f, %4.2f", leftFrontPower, rightFrontPower);
+        telemetry.addData("Back  left/Right", "%4.2f, %4.2f", leftBackPower, rightBackPower);
+        telemetry.addData("Current Lift Position", lift.getPosition());
+        telemetry.update();
+
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/PedroConstants.java

@@ -10,8 +10,11 @@ public class PedroConstants {
     /*
         Robot parameters
     */
+    // Turn localizer - -0.003
+
 
     // Robot motor configurations
+    public static final String BRAIN_ROT = "Sikidi rizz 360 no teleop tf2 mama mia 2cool 4skool yasyasy yasyasyasyasyasyasyaysy ohio yes heh me is moar skeebeedee than u walked and got tripped on by your aunt my very educaded mother just served us nine what? just kydinfoiwfowefwofwioefoiejfeoiwjfomdsklfnslefknesfklnkfenfenkfeknfenkfeknfenkefnk";
     public static final String FRONT_LEFT_MOTOR = "Drive front lt";
     public static final String BACK_LEFT_MOTOR  = "Drive back lt";
     public static final String FRONT_RIGHT_MOTOR  = "Drive front rt";
@@ -20,38 +23,51 @@ public class PedroConstants {
     // Robot motor direction
     public static final Direction FRONT_LEFT_MOTOR_DIRECTION = Direction.REVERSE;
     public static final Direction BACK_LEFT_MOTOR_DIRECTION = Direction.REVERSE;
-    public static final Direction FRONT_RIGHT_MOTOR_DIRECTION = Direction.REVERSE;
-    public static final Direction BACK_RIGHT_MOTOR_DIRECTION = Direction.REVERSE;
+    public static final Direction FRONT_RIGHT_MOTOR_DIRECTION = Direction.FORWARD;
+    public static final Direction BACK_RIGHT_MOTOR_DIRECTION = Direction.FORWARD;
+
+    // Robot IMU configuration
+    public static final String IMU = "imu";
+
+    // Robot IMU placement
+    public static final RevHubOrientationOnRobot.LogoFacingDirection IMU_LOGO_FACING_DIRECTION
+            = RevHubOrientationOnRobot.LogoFacingDirection.DOWN;
+    public static final RevHubOrientationOnRobot.UsbFacingDirection IMU_USB_FACING_DIRECTION
+            = RevHubOrientationOnRobot.UsbFacingDirection.LEFT;
+
+    // Robot encoders
+    public static final String LEFT_ENCODER = "encoder left";
+    public static final String RIGHT_ENCODER = "encoder right";
+    public static final String BACK_ENCODER = "encoder back";
 
     // Robot encoder direction
-    public static final double FRONT_LEFT_MOTOR_ENCODER = Encoder.FORWARD;
-    public static final double BACK_LEFT_MOTOR_ENCODER = Encoder.FORWARD;
-    public static final double FRONT_RIGHT_MOTOR_ENCODER = Encoder.FORWARD;
-    public static final double BACK_RIGHT_MOTOR_ENCODER = Encoder.FORWARD;
+    public static final double LEFT_ENCODER_DIRECTION = Encoder.FORWARD;
+    public static final double RIGHT_ENCODER_DIRECTION = Encoder.FORWARD;
+    public static final double BACK_ENCODER_DIRECTION = Encoder.FORWARD;
 
     /*
         Pedro's parameters
     */
 
     // The weight of the robot in Kilograms
-    public static final double ROBOT_WEIGHT_IN_KG = 5.15;
+    public static final double ROBOT_WEIGHT_IN_KG = 10.5;
 
     // Maximum velocity of the robot going forward
-    public static final double ROBOT_SPEED_FORWARD = 66.6117;
+    public static final double ROBOT_SPEED_FORWARD = 51.4598;
 
     // Maximum velocity of the robot going right
-    public static final double ROBOT_SPEED_LATERAL = 60.0671;
+    public static final double ROBOT_SPEED_LATERAL = 28.7119;
 
     // Rate of deceleration when power is cut-off when the robot is moving forward
-    public static final double FORWARD_ZERO_POWER_ACCEL = -71.154;
+    public static final double FORWARD_ZERO_POWER_ACCEL = -59.805;
 
     // Rate of deceleration when power is cut-off when the robot is moving to the right
-    public static final double LATERAL_ZERO_POWER_ACCEL = -109.5358;
+    public static final double LATERAL_ZERO_POWER_ACCEL = -99.672;
 
     // Determines how fast your robot will decelerate as a factor of how fast your robot will coast to a stop
-    public static final double ZERO_POWER_ACCEL_MULT = 4.0;
+    public static final double ZERO_POWER_ACCEL_MULT = 3.5;
 
     /* Centripetal force correction - increase if robot is correcting into the path
                                     - decrease if robot is correcting away from the path */
-    public static final double CENTRIPETAL_SCALING = 0.0005;
+    public static final double CENTRIPETAL_SCALING = 0.0004;
 }

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AsherPathV1.java

@@ -0,0 +1,135 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AsherPathV1", group = "Autonomous Pathing Tuning")
+public class AsherPathV1 extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(10.0, 40, 90);
+
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.4);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                /*
+                * Only update this path
+                 */
+                .addPath(
+                        // Line 1
+                        new BezierCurve(
+                                new Point(9.757, 84.983, Point.CARTESIAN),
+                                new Point(33.000, 105.000, Point.CARTESIAN),
+                                new Point(80.000, 118.000, Point.CARTESIAN),
+                                new Point(55.000, 120.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(55.000, 120.000, Point.CARTESIAN),
+                                new Point(22.000, 106.000, Point.CARTESIAN),
+                                new Point(11.000, 131.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 3
+                        new BezierCurve(
+                                new Point(11.000, 131.000, Point.CARTESIAN),
+                                new Point(75.000, 95.000, Point.CARTESIAN),
+                                new Point(112.000, 132.000, Point.CARTESIAN),
+                                new Point(61.000, 131.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(61.000, 131.000, Point.CARTESIAN),
+                                new Point(11.000, 131.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 5
+                        new BezierCurve(
+                                new Point(11.000, 131.000, Point.CARTESIAN),
+                                new Point(100.000, 118.000, Point.CARTESIAN),
+                                new Point(103.000, 135.000, Point.CARTESIAN),
+                                new Point(61.000, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(61.000, 135.000, Point.CARTESIAN),
+                                new Point(11.000, 131.000, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 7
+                        new BezierCurve(
+                                new Point(11.000, 131.000, Point.CARTESIAN),
+                                new Point(113.000, 95.000, Point.CARTESIAN),
+                                new Point(67.000, 95.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+                /*
+                * End of only update this path
+                 */
+
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExample.java

@@ -0,0 +1,79 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AutoExample - Straight Path", group = "Autonomous Pathing Tuning")
+public class AutoExample extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(0.0, 20.0, 0);
+
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.6);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(0.000, 20.000, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .build();
+
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleFour.java

@@ -1,17 +1,10 @@
-package org.firstinspires.ftc.teamcode;
-
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+package org.firstinspires.ftc.teamcode.cometbots;
 
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;
 import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
 import com.qualcomm.robotcore.eventloop.opmode.OpMode;
-import com.qualcomm.robotcore.hardware.DcMotor;
-import com.qualcomm.robotcore.hardware.DcMotorEx;
 
 import org.firstinspires.ftc.robotcore.external.Telemetry;
 import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
@@ -33,15 +26,15 @@ import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
  * @version 1.0, 3/12/2024
  */
 @Config
-@Autonomous(name = "AutoExample", group = "Autonomous Pathing Tuning")
-public class AutoExample extends OpMode {
+@Autonomous(name = "AutoExample - 2 Curves/2 Lines", group = "Autonomous Pathing Tuning")
+public class AutoExampleFour extends OpMode {
     private Telemetry telemetryA;
 
     private Follower follower;
 
     private PathChain path;
 
-    private final Pose startPose = new Pose(12.0, 11, 90);
+    private final Pose startPose = new Pose(12,60, 0);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -51,54 +44,45 @@ public class AutoExample extends OpMode {
     public void init() {
         follower = new Follower(hardwareMap);
 
-        follower.setMaxPower(.6);
+        follower.setMaxPower(.45);
 
         follower.setStartingPose(startPose);
 
         path = follower.pathBuilder()
                 .addPath(
                         // Line 1
-                        new BezierLine(
-                                new Point(12.804, 11.223, Point.CARTESIAN),
-                                new Point(12.804, 42.362, Point.CARTESIAN)
+                        new BezierCurve(
+                                new Point(12.000, 60.000, Point.CARTESIAN),
+                                new Point(60.000, 60.000, Point.CARTESIAN),
+                                new Point(60.000, 12.000, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
                 .addPath(
                         // Line 2
-                        new BezierCurve(
-                                new Point(12.804, 42.362, Point.CARTESIAN),
-                                new Point(11.381, 57.379, Point.CARTESIAN),
-                                new Point(31.614, 56.588, Point.CARTESIAN)
+                        new BezierLine(
+                                new Point(60.000, 12.000, Point.CARTESIAN),
+                                new Point(40.000, 12.000, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
                 .addPath(
                         // Line 3
-                        new BezierLine(
-                                new Point(31.614, 56.588, Point.CARTESIAN),
-                                new Point(51.214, 56.746, Point.CARTESIAN)
+                        new BezierCurve(
+                                new Point(40.000, 12.000, Point.CARTESIAN),
+                                new Point(35.000, 35.000, Point.CARTESIAN),
+                                new Point(12.000, 35.000, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
                 .addPath(
                         // Line 4
-                        new BezierCurve(
-                                new Point(51.214, 56.746, Point.CARTESIAN),
-                                new Point(64.334, 58.643, Point.CARTESIAN),
-                                new Point(61.172, 45.524, Point.CARTESIAN)
+                        new BezierLine(
+                                new Point(12.000, 35.000, Point.CARTESIAN),
+                                new Point(12.000, 60.000, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
-                .addPath(
-                        // Line 5
-                        new BezierCurve(
-                                new Point(61.172, 45.524, Point.CARTESIAN),
-                                new Point(36.198, 26.239, Point.CARTESIAN),
-                                new Point(19.759, 11.065, Point.CARTESIAN)
-                        )
-                )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(0))
                 .build();
 
         follower.followPath(path);

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleSeason2025V1.java

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots;
 
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleThree.java

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots;
 
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;
@@ -26,7 +26,7 @@ import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
  * @version 1.0, 3/12/2024
  */
 @Config
-@Autonomous(name = "AutoExampleThree", group = "Autonomous Pathing Tuning")
+@Autonomous(name = "AutoExample - Curve and Line", group = "Autonomous Pathing Tuning")
 public class AutoExampleThree extends OpMode {
     private Telemetry telemetryA;
 
@@ -34,7 +34,7 @@ public class AutoExampleThree extends OpMode {
 
     private PathChain path;
 
-    private final Pose startPose = new Pose(10.0, 40, 90);
+    private final Pose startPose = new Pose(10,45, 0);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -52,12 +52,21 @@ public class AutoExampleThree extends OpMode {
                 .addPath(
                         // Line 1
                         new BezierCurve(
-                                new Point(10.000, 20.000, Point.CARTESIAN),
-                                new Point(29.089, 61.232, Point.CARTESIAN),
-                                new Point(48.054, 19.607, Point.CARTESIAN)
+                                new Point(10.000, 45.000, Point.CARTESIAN),
+                                new Point(45.000, 45.000, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(50.000, 20.000, Point.CARTESIAN),
+                                new Point(10.000, 20.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
+                .build();
 
         follower.followPath(path);
 

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleTwo.java

@@ -0,0 +1,80 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AutoExample - Simple Curve", group = "Autonomous Pathing Tuning")
+public class AutoExampleTwo extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(10.0, 45, 0);
+
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.4);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                .addPath(
+                        // Line 1
+                        new BezierCurve(
+                                new Point(10.000, 45.000, Point.CARTESIAN),
+                                new Point(45.000, 45.000, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
+                .build();
+
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BasicOmniOpMode_Linear.java

@@ -27,8 +27,10 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots;
 
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
@@ -37,6 +39,10 @@ import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
 import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
 import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
 import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER_DIRECTION;
 
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
 import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
@@ -74,15 +80,12 @@ import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
  * Remove or comment out the @Disabled line to add this OpMode to the Driver Station OpMode list
  */
 
-@TeleOp(name = "Basic: Omni Linear OpMode", group = "Linear OpMode")
+@TeleOp(name="Basic: Omni Linear OpMode", group="Linear OpMode")
 public class BasicOmniOpMode_Linear extends LinearOpMode {
 
     // Declare OpMode members for each of the 4 motors.
     private final ElapsedTime runtime = new ElapsedTime();
-    private Encoder leftFront;
-    private Encoder rightFront;
-    private Encoder leftRear;
-    private Encoder rightRear;
+
     @Override
     public void runOpMode() {
 
@@ -93,12 +96,18 @@ public class BasicOmniOpMode_Linear extends LinearOpMode {
         DcMotor rightFrontDrive = hardwareMap.get(DcMotor.class, FRONT_RIGHT_MOTOR);
         DcMotor rightBackDrive = hardwareMap.get(DcMotor.class, BACK_RIGHT_MOTOR);
 
-        leftFront = new Encoder(hardwareMap.get(DcMotorEx.class, FRONT_LEFT_MOTOR));
-        leftRear = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_LEFT_MOTOR));
-        rightRear = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_RIGHT_MOTOR));
-        rightFront = new Encoder(hardwareMap.get(DcMotorEx.class, FRONT_RIGHT_MOTOR));
 
 
+        // TODO: replace these with your encoder ports
+        Encoder leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+        Encoder rightEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, RIGHT_ENCODER));
+        Encoder strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+        // TODO: reverse any encoders necessary
+        leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+        rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+        strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+
         // ########################################################################################
         // !!!            IMPORTANT Drive Information. Test your motor directions.            !!!!!
         // ########################################################################################
@@ -114,20 +123,11 @@ public class BasicOmniOpMode_Linear extends LinearOpMode {
         rightFrontDrive.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
         rightBackDrive.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
 
-        leftFrontDrive.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
-        leftBackDrive.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
-        rightFrontDrive.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
-        rightBackDrive.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
-
-        leftFrontDrive.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
-        leftBackDrive.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
-        rightFrontDrive.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
-        rightBackDrive.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
-
-
-
         // Wait for the game to start (driver presses START)
         telemetry.addData("Status", "Initialized");
+        telemetry.addData("Left Encoder Value", leftEncoder.getDeltaPosition());
+        telemetry.addData("Right Encoder Value", rightEncoder.getDeltaPosition());
+        telemetry.addData("Strafe Encoder Value", strafeEncoder.getDeltaPosition());
         telemetry.update();
 
         waitForStart();
@@ -138,16 +138,16 @@ public class BasicOmniOpMode_Linear extends LinearOpMode {
             double max;
 
             // POV Mode uses left joystick to go forward & strafe, and right joystick to rotate.
-            double axial = -gamepad1.left_stick_y;  // Note: pushing stick forward gives negative value
-            double lateral = gamepad1.left_stick_x;
-            double yaw = gamepad1.right_stick_x;
+            double axial   = -gamepad1.left_stick_y;  // Note: pushing stick forward gives negative value
+            double lateral =  gamepad1.left_stick_x;
+            double yaw     =  gamepad1.right_stick_x;
 
             // Combine the joystick requests for each axis-motion to determine each wheel's power.
             // Set up a variable for each drive wheel to save the power level for telemetry.
-            double leftFrontPower = axial + lateral + yaw;
+            double leftFrontPower  = axial + lateral + yaw;
             double rightFrontPower = axial - lateral - yaw;
-            double leftBackPower = axial - lateral + yaw;
-            double rightBackPower = axial + lateral - yaw;
+            double leftBackPower   = axial - lateral + yaw;
+            double rightBackPower  = axial + lateral - yaw;
 
             // Normalize the values so no wheel power exceeds 100%
             // This ensures that the robot maintains the desired motion.
@@ -156,10 +156,10 @@ public class BasicOmniOpMode_Linear extends LinearOpMode {
             max = Math.max(max, Math.abs(rightBackPower));
 
             if (max > 1.0) {
-                leftFrontPower /= max;
+                leftFrontPower  /= max;
                 rightFrontPower /= max;
-                leftBackPower /= max;
-                rightBackPower /= max;
+                leftBackPower   /= max;
+                rightBackPower  /= max;
             }
 
             // This is test code:
@@ -186,14 +186,12 @@ public class BasicOmniOpMode_Linear extends LinearOpMode {
             rightBackDrive.setPower(rightBackPower);
 
             // Show the elapsed game time and wheel power.
-            telemetry.addData("Status", "Run Time: " + runtime);
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
             telemetry.addData("Front left/Right", "%4.2f, %4.2f", leftFrontPower, rightFrontPower);
             telemetry.addData("Back  left/Right", "%4.2f, %4.2f", leftBackPower, rightBackPower);
-            telemetry.addData("Encoder Front Left", leftFrontDrive.getDirection() + " : " + leftFrontDrive.getCurrentPosition());
-            telemetry.addData("Encoder Front Right", rightFrontDrive.getCurrentPosition());
-            telemetry.addData("Encoder Back Left", leftBackDrive.getCurrentPosition());
-            telemetry.addData("Encoder Back Right", rightBackDrive.getCurrentPosition());
+            telemetry.addData("Left Encoder Value", leftEncoder.getDeltaPosition());
+            telemetry.addData("Right Encoder Value", rightEncoder.getDeltaPosition());
+            telemetry.addData("Strafe Encoder Value", strafeEncoder.getDeltaPosition());
             telemetry.update();
         }
-    }
-}
+    }}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BlueBasketAuto.java

@@ -0,0 +1,161 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "BlueBasketAuto", group = "Autonomous Pathing Tuning")
+public class BlueBasketAuto extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(11.25, 95.75);
+
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.45);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(11.250, 95.750, Point.CARTESIAN),
+                                new Point(37.000, 108.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(37.000, 108.000, Point.CARTESIAN),
+                                new Point(73.286, 111.536, Point.CARTESIAN),
+                                new Point(67.821, 120.536, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(67.821, 120.536, Point.CARTESIAN),
+                                new Point(28.000, 121.500, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(28.000, 121.500, Point.CARTESIAN),
+                                new Point(18.000, 130.179, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 5
+                        new BezierCurve(
+                                new Point(18.000, 130.179, Point.CARTESIAN),
+                                new Point(59.000, 102.500, Point.CARTESIAN),
+                                new Point(68.700, 130.500, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(68.700, 130.500, Point.CARTESIAN),
+                                new Point(18.000, 130.339, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 7
+                        new BezierCurve(
+                                new Point(18.000, 130.339, Point.CARTESIAN),
+                                new Point(49.018, 121.179, Point.CARTESIAN),
+                                new Point(63.804, 135.321, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(63.804, 135.321, Point.CARTESIAN),
+                                new Point(53.036, 135.161, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(53.036, 135.161, Point.CARTESIAN),
+                                new Point(18.643, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(18.643, 135.000, Point.CARTESIAN),
+                                new Point(72.300, 97.400, Point.CARTESIAN)
+                        )
+                )
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(18.643, 135.000, Point.CARTESIAN),
+                                new Point(83.250, 95.464, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(270)).build();
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluebAutoV1.java

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots;
 
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;
@@ -9,7 +9,6 @@ import com.qualcomm.robotcore.eventloop.opmode.OpMode;
 import org.firstinspires.ftc.robotcore.external.Telemetry;
 import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
 import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
-import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
 import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
 import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
 import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluenbAutov1.java

@@ -0,0 +1,4 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+public class BluenbAutov1 {
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/SensorIMUOrthogonal.java

@@ -0,0 +1,172 @@
+/* Copyright (c) 2022 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.IMU_LOGO_FACING_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.IMU_USB_FACING_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER_DIRECTION;
+
+import com.qualcomm.hardware.rev.RevHubOrientationOnRobot;
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.IMU;
+
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.robotcore.external.navigation.AngularVelocity;
+import org.firstinspires.ftc.robotcore.external.navigation.YawPitchRollAngles;
+import org.firstinspires.ftc.teamcode.PedroConstants;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+
+/*
+ * This OpMode shows how to use the new universal IMU interface. This
+ * interface may be used with the BNO055 IMU or the BHI260 IMU. It assumes that an IMU is configured
+ * on the robot with the name "imu".
+ *
+ * The sample will display the current Yaw, Pitch and Roll of the robot.<br>
+ * With the correct orientation parameters selected, pitch/roll/yaw should act as follows:
+ *   Pitch value should INCREASE as the robot is tipped UP at the front. (Rotation about X) <br>
+ *   Roll value should INCREASE as the robot is tipped UP at the left side. (Rotation about Y) <br>
+ *   Yaw value should INCREASE as the robot is rotated Counter Clockwise. (Rotation about Z) <br>
+ *
+ * The yaw can be reset (to zero) by pressing the Y button on the gamepad (Triangle on a PS4 controller)
+ *
+ * This specific sample assumes that the Hub is mounted on one of the three orthogonal planes
+ * (X/Y, X/Z or Y/Z) and that the Hub has only been rotated in a range of 90 degree increments.
+ *
+ * Note: if your Hub is mounted on a surface angled at some non-90 Degree multiple (like 30) look at
+ *       the alternative SensorIMUNonOrthogonal sample in this folder.
+ *
+ * This "Orthogonal" requirement means that:
+ *
+ * 1) The Logo printed on the top of the Hub can ONLY be pointing in one of six directions:
+ *    FORWARD, BACKWARD, UP, DOWN, LEFT and RIGHT.
+ *
+ * 2) The USB ports can only be pointing in one of the same six directions:<br>
+ *    FORWARD, BACKWARD, UP, DOWN, LEFT and RIGHT.
+ *
+ * So, To fully define how your Hub is mounted to the robot, you must simply specify:<br>
+ *    logoFacingDirection<br>
+ *    usbFacingDirection
+ *
+ * Use Android Studio to Copy this Class, and Paste it into your team's code folder with a new name.
+ * Remove or comment out the @Disabled line to add this OpMode to the Driver Station OpMode list.
+ *
+ * Finally, choose the two correct parameters to define how your Hub is mounted and edit this OpMode
+ * to use those parameters.
+ */
+@TeleOp(name = "Sensor: IMU Orthogonal", group = "Sensor")
+@Disabled   // Comment this out to add to the OpMode list
+public class SensorIMUOrthogonal extends LinearOpMode {
+    // The IMU sensor object
+    IMU imu;
+    private Encoder leftEncoder;
+    private Encoder rightEncoder;
+    private Encoder strafeEncoder;
+
+    //----------------------------------------------------------------------------------------------
+    // Main logic
+    //----------------------------------------------------------------------------------------------
+
+    @Override
+    public void runOpMode() throws InterruptedException {
+
+        // Retrieve and initialize the IMU.
+        // This sample expects the IMU to be in a REV Hub and named "imu".
+        imu = hardwareMap.get(IMU.class, PedroConstants.IMU);
+
+        // TODO: replace these with your encoder ports
+        leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+        rightEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, RIGHT_ENCODER));
+        strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+        // TODO: reverse any encoders necessary
+        leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+        rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+        strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+
+        /* Define how the hub is mounted on the robot to get the correct Yaw, Pitch and Roll values.
+         *
+         * Two input parameters are required to fully specify the Orientation.
+         * The first parameter specifies the direction the printed logo on the Hub is pointing.
+         * The second parameter specifies the direction the USB connector on the Hub is pointing.
+         * All directions are relative to the robot, and left/right is as-viewed from behind the robot.
+         *
+         * If you are using a REV 9-Axis IMU, you can use the Rev9AxisImuOrientationOnRobot class instead of the
+         * RevHubOrientationOnRobot class, which has an I2cPortFacingDirection instead of a UsbFacingDirection.
+         */
+
+        /* The next two lines define Hub orientation.
+         * The Default Orientation (shown) is when a hub is mounted horizontally with the printed logo pointing UP and the USB port pointing FORWARD.
+         *
+         * To Do:  EDIT these two lines to match YOUR mounting configuration.
+         */
+        RevHubOrientationOnRobot.LogoFacingDirection logoDirection = IMU_LOGO_FACING_DIRECTION;
+        RevHubOrientationOnRobot.UsbFacingDirection usbDirection = IMU_USB_FACING_DIRECTION;
+
+        RevHubOrientationOnRobot orientationOnRobot = new RevHubOrientationOnRobot(logoDirection, usbDirection);
+
+        // Now initialize the IMU with this mounting orientation
+        // Note: if you choose two conflicting directions, this initialization will cause a code exception.
+        imu.initialize(new IMU.Parameters(orientationOnRobot));
+
+        // Loop and update the dashboard
+        while (!isStopRequested()) {
+
+            telemetry.addData("Hub orientation", "Logo=%s   USB=%s\n ", logoDirection, usbDirection);
+
+            // Check to see if heading reset is requested
+            if (gamepad1.y) {
+                telemetry.addData("Yaw", "Resetting\n");
+                imu.resetYaw();
+            } else {
+                telemetry.addData("Yaw", "Press Y (triangle) on Gamepad to reset\n");
+            }
+
+            // Retrieve Rotational Angles and Velocities
+            YawPitchRollAngles orientation = imu.getRobotYawPitchRollAngles();
+            AngularVelocity angularVelocity = imu.getRobotAngularVelocity(AngleUnit.DEGREES);
+
+            telemetry.addData("Yaw (Z)", "%.2f Deg. (Heading)", orientation.getYaw(AngleUnit.DEGREES));
+            telemetry.addData("Pitch (X)", "%.2f Deg.", orientation.getPitch(AngleUnit.DEGREES));
+            telemetry.addData("Roll (Y)", "%.2f Deg.\n", orientation.getRoll(AngleUnit.DEGREES));
+            telemetry.addData("Yaw (Z) velocity", "%.2f Deg/Sec", angularVelocity.zRotationRate);
+            telemetry.addData("Pitch (X) velocity", "%.2f Deg/Sec", angularVelocity.xRotationRate);
+            telemetry.addData("Roll (Y) velocity", "%.2f Deg/Sec", angularVelocity.yRotationRate);
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/tests/ArmTest.java

@@ -0,0 +1,95 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots.tests;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+import org.firstinspires.ftc.teamcode.subsystem.ArmSubsystem;
+
+@TeleOp(name = "Arm Test", group = "Debug")
+public class ArmTest extends LinearOpMode {
+
+    // Declare OpMode members for each of the 4 motors.
+    private final ElapsedTime runtime = new ElapsedTime();
+
+    @Override
+    public void runOpMode() {
+
+        /*
+         * Instantiate Arm
+         */
+        ArmSubsystem arm = new ArmSubsystem(hardwareMap, ArmSubsystem.ArmState.PARK);
+
+        /*
+         * Instantiate gamepad state holders
+         */
+        Gamepad currentGamepad1 = new Gamepad();
+        Gamepad previousGamepad1 = new Gamepad();
+
+        arm.init();
+        waitForStart();
+        runtime.reset();
+
+        // run until the end of the match (driver presses STOP)
+        while (opModeIsActive()) {
+
+            previousGamepad1.copy(currentGamepad1);
+            currentGamepad1.copy(gamepad1);
+
+            if (currentGamepad1.circle && !previousGamepad1.circle) {
+                arm.parkArm();
+            }
+
+            if (currentGamepad1.square && !previousGamepad1.square) {
+                arm.engageArm();
+            }
+
+            if (currentGamepad1.cross && !previousGamepad1.cross) {
+                arm.switchState();
+            }
+
+            if (currentGamepad1.left_bumper && !previousGamepad1.left_bumper) {
+                arm.setPosition(arm.getPosition() - .05);
+            }
+
+            if (currentGamepad1.right_bumper && !previousGamepad1.right_bumper) {
+                arm.setPosition(arm.getPosition() + .05);
+            }
+
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
+            telemetry.addData("Arm State", arm.getState());
+            telemetry.addData("Arm Position", arm.getPosition());
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/tests/ClawTest.java

@@ -0,0 +1,78 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots.tests;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+
+@TeleOp(name = "Claw Test", group = "Debug")
+public class ClawTest extends LinearOpMode {
+
+    // Declare OpMode members for each of the 4 motors.
+    private final ElapsedTime runtime = new ElapsedTime();
+
+    @Override
+    public void runOpMode() {
+
+        /*
+         * Instantiate Claw
+         */
+        ClawSubsystem claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.OPEN);
+
+        /*
+         * Instantiate gamepad state holders
+         */
+        Gamepad currentGamepad1 = new Gamepad();
+        Gamepad previousGamepad1 = new Gamepad();
+
+        waitForStart();
+        runtime.reset();
+
+        // run until the end of the match (driver presses STOP)
+        while (opModeIsActive()) {
+
+            previousGamepad1.copy(currentGamepad1);
+            currentGamepad1.copy(gamepad1);
+
+            if (currentGamepad1.cross && !previousGamepad1.cross) {
+                claw.switchState();
+            }
+
+            // Show the elapsed game time and wheel power.
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
+            telemetry.addData("Claw State", claw.getState());
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/tests/LiftRawTest.java

@@ -0,0 +1,124 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots.tests;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.DcMotorSimple;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+@TeleOp(name = "Lift Raw Test", group = "Debug")
+public class LiftRawTest extends LinearOpMode {
+
+    // Declare OpMode members for each of the 4 motors.
+    private final ElapsedTime runtime = new ElapsedTime();
+
+    private final int MIN_POINT = 0;
+    private final int MAX_POINT = 3700;
+
+    @Override
+    public void runOpMode() {
+
+        /*
+         * Instantiate Lift
+         */
+        DcMotor liftDrive = hardwareMap.get(DcMotor.class, "lift-motor");
+        liftDrive.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
+        liftDrive.setDirection(DcMotorSimple.Direction.REVERSE);
+
+        /*
+         * Instantiate gamepad state holders
+         */
+        Gamepad currentGamepad1 = new Gamepad();
+        Gamepad previousGamepad1 = new Gamepad();
+
+        waitForStart();
+        runtime.reset();
+
+
+        // run until the end of the match (driver presses STOP)
+        while (opModeIsActive()) {
+
+            previousGamepad1.copy(currentGamepad1);
+            currentGamepad1.copy(gamepad1);
+
+            liftDrive.setPower(.5);
+
+            // Max position is 6800, safely setting to 6500
+
+            if (currentGamepad1.square && !previousGamepad1.square) {
+                liftDrive.setTargetPosition(MIN_POINT);
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            if (currentGamepad1.triangle && !previousGamepad1.triangle) {
+                liftDrive.setTargetPosition(1500);
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            if (currentGamepad1.circle && !previousGamepad1.circle) {
+                liftDrive.setTargetPosition(2750);
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            if (currentGamepad1.cross && !previousGamepad1.cross) {
+                liftDrive.setTargetPosition(MAX_POINT);
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            if (currentGamepad1.left_bumper && !previousGamepad1.left_bumper) {
+                int newPosition = liftDrive.getCurrentPosition() - 125;
+                if (newPosition < MIN_POINT) {
+                    liftDrive.setTargetPosition(MIN_POINT);
+                } else {
+                    liftDrive.setTargetPosition(newPosition);
+                }
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            if (currentGamepad1.right_bumper && !previousGamepad1.right_bumper) {
+                int newPosition = liftDrive.getCurrentPosition() + 125;
+                if (newPosition > MAX_POINT) {
+                    liftDrive.setTargetPosition(MAX_POINT);
+                } else {
+                    liftDrive.setTargetPosition(newPosition);
+                }
+                liftDrive.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+            }
+
+            // Show the elapsed game time and wheel power.
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
+            telemetry.addData("Lift Drive Position", liftDrive.getCurrentPosition());
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/tests/LiftTest.java

@@ -0,0 +1,98 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots.tests;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+import org.firstinspires.ftc.teamcode.subsystem.LiftSubsystem;
+
+@TeleOp(name = "Lift Test", group = "Debug")
+public class LiftTest extends LinearOpMode {
+
+    // Declare OpMode members for each of the 4 motors.
+    private final ElapsedTime runtime = new ElapsedTime();
+
+    private final int MIN_POINT = 0;
+    // 2000 ~ 2500
+
+    // 3750 max
+    private final int MAX_POINT = 6500;
+
+    @Override
+    public void runOpMode() {
+
+        /*
+         * Instantiate Lift
+         */
+        LiftSubsystem lift = new LiftSubsystem(hardwareMap);
+
+        /*
+         * Instantiate gamepad state holders
+         */
+        Gamepad currentGamepad1 = new Gamepad();
+        Gamepad previousGamepad1 = new Gamepad();
+
+        lift.init();
+        waitForStart();
+        runtime.reset();
+
+
+        // run until the end of the match (driver presses STOP)
+        while (opModeIsActive()) {
+
+            previousGamepad1.copy(currentGamepad1);
+            currentGamepad1.copy(gamepad1);
+
+            if (currentGamepad1.square && !previousGamepad1.square) {
+                lift.toFloor();
+            }
+
+            if (currentGamepad1.triangle && !previousGamepad1.triangle) {
+                lift.toHighBucket();
+            }
+
+            if (currentGamepad1.circle && !previousGamepad1.circle) {
+                lift.toLowBucket();
+            }
+
+            if (currentGamepad1.cross && !previousGamepad1.cross) {
+                lift.switchState();
+            }
+
+            // Show the elapsed game time and wheel power.
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
+            telemetry.addData("Lift Drive Position", lift.getPosition());
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/tests/WristTest.java

@@ -0,0 +1,96 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots.tests;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+import org.firstinspires.ftc.teamcode.subsystem.WristSubsystem;
+
+@TeleOp(name = "Wrist Test", group = "Debug")
+public class WristTest extends LinearOpMode {
+
+    // Declare OpMode members for each of the 4 motors.
+    private final ElapsedTime runtime = new ElapsedTime();
+
+    @Override
+    public void runOpMode() {
+
+        /*
+         * Instantiate Wrist
+         */
+        WristSubsystem wrist = new WristSubsystem(hardwareMap, WristSubsystem.WristState.FLOOR);
+
+        /*
+         * Instantiate gamepad state holders
+         */
+        Gamepad currentGamepad1 = new Gamepad();
+        Gamepad previousGamepad1 = new Gamepad();
+
+        wrist.init();
+        waitForStart();
+        runtime.reset();
+
+        // run until the end of the match (driver presses STOP)
+        while (opModeIsActive()) {
+
+            previousGamepad1.copy(currentGamepad1);
+            currentGamepad1.copy(gamepad1);
+
+            if (currentGamepad1.square && !previousGamepad1.square) {
+                wrist.bucketWrist();
+            }
+
+            if (currentGamepad1.circle && !previousGamepad1.circle) {
+                wrist.floorWrist();
+            }
+
+            if (currentGamepad1.cross && !previousGamepad1.cross) {
+                wrist.switchState();
+            }
+
+            if (currentGamepad1.left_bumper && !previousGamepad1.left_bumper) {
+                wrist.setPosition(wrist.getPosition() - .05);
+            }
+
+            if (currentGamepad1.right_bumper && !previousGamepad1.right_bumper) {
+                wrist.setPosition(wrist.getPosition() + .05);
+            }
+
+            // Show the elapsed game time and wheel power.
+            telemetry.addData("Status", "Run Time: " + runtime.toString());
+            telemetry.addData("Wrist State", wrist.getState());
+            telemetry.addData("Wrist Position", wrist.getPosition());
+            telemetry.update();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/configs/RobotConstants.java

@@ -0,0 +1,22 @@
+package org.firstinspires.ftc.teamcode.configs;
+
+import com.acmerobotics.dashboard.config.Config;
+
+@Config
+public class RobotConstants {
+    public static double clawClose = 1.00;
+    public static double clawOpen = 0.05;
+
+    public static double armEngage = 0.5;
+    public static double armPark = 0.125;
+    public static double armBucket = 0.175;
+
+    public static double wristFloor = 0.625;
+    public static double wristBucket = 0.215;
+    public static int liftToFloorPos = 20;
+    public static int liftToFloatPos = 150;
+    public static int liftToLowBucketPos = 2250;
+    public static int liftToHighBucketPos = 3900;
+    public static double liftPower = .45;
+    public static int liftToHoverState = 60;
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/TUNING.md

@@ -71,8 +71,9 @@ measurements will be in centimeters.
   of how fast your robot will coast to a stop. Honestly, this is up to you. I personally used 4, but
   what works best for you is most important. Higher numbers will cause a faster brake, but increase
   oscillations at the end. Lower numbers will do the opposite. This can be found on line `107` in
-  `FollowerConstants`, named `zeroPowerAccelerationMultiplier`. The drive PID is much, much more 
-* sensitive than the others. For reference,
+  `FollowerConstants`, named `zeroPowerAccelerationMultiplier`. 
+
+* The drive PID is much, much more sensitive than the others. For reference,
   my P values were in the hundredths and thousandths place values, and my D values were in the hundred
   thousandths and millionths place values. To tune this, enable `useDrive`, `useHeading`, and
   `useTranslational` in the `Follower` dropdown in FTC Dashboard. Next, run `StraightBackAndForth`

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/PoseUpdater.java

@@ -6,6 +6,9 @@ import com.qualcomm.robotcore.hardware.IMU;
 
 import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
 import org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers.DriveEncoderLocalizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers.ThreeWheelIMULocalizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers.ThreeWheelLocalizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers.TwoWheelLocalizer;
 import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.MathFunctions;
 import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Vector;
 
@@ -67,7 +70,8 @@ public class PoseUpdater {
      */
     public PoseUpdater(HardwareMap hardwareMap) {
         // TODO: replace the second argument with your preferred localizer
-        this(hardwareMap, new DriveEncoderLocalizer(hardwareMap));
+        this(hardwareMap, new ThreeWheelLocalizer(hardwareMap));
+//        this(hardwareMap, new ThreeWheelIMULocalizer(hardwareMap));
     }
 
     /**

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/localizers/DriveEncoderLocalizer.java

@@ -1,20 +1,11 @@
 package org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers;
 
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_ENCODER;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_ENCODER;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_ENCODER;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_ENCODER;
+import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.leftFrontMotorName;
+import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.leftRearMotorName;
+import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.rightFrontMotorName;
+import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.rightRearMotorName;
 
 import com.acmerobotics.dashboard.config.Config;
-import com.qualcomm.robotcore.hardware.DcMotor;
 import com.qualcomm.robotcore.hardware.DcMotorEx;
 import com.qualcomm.robotcore.hardware.HardwareMap;
 
@@ -35,21 +26,21 @@ import org.firstinspires.ftc.teamcode.pedroPathing.util.NanoTimer;
  */
 @Config
 public class DriveEncoderLocalizer extends Localizer {
-    private final HardwareMap hardwareMap;
+    private HardwareMap hardwareMap;
     private Pose startPose;
     private Pose displacementPose;
     private Pose currentVelocity;
     private Matrix prevRotationMatrix;
-    private final NanoTimer timer;
+    private NanoTimer timer;
     private long deltaTimeNano;
-    private final Encoder leftFront;
-    private final Encoder rightFront;
-    private final Encoder leftRear;
-    private final Encoder rightRear;
+    private Encoder leftFront;
+    private Encoder rightFront;
+    private Encoder leftRear;
+    private Encoder rightRear;
     private double totalHeading;
-    public static double FORWARD_TICKS_TO_INCHES = -0.0058;
-    public static double STRAFE_TICKS_TO_INCHES = -0.0054;
-    public static double TURN_TICKS_TO_RADIANS = -0.0009;
+    public static double FORWARD_TICKS_TO_INCHES = -0.6308;
+    public static double STRAFE_TICKS_TO_INCHES = 46.4839;
+    public static double TURN_TICKS_TO_RADIANS = -0.002;
     public static double ROBOT_WIDTH = 1;
     public static double ROBOT_LENGTH = 1;
 
@@ -67,32 +58,22 @@ public class DriveEncoderLocalizer extends Localizer {
      * This creates a new DriveEncoderLocalizer from a HardwareMap and a Pose, with the Pose
      * specifying the starting pose of the localizer.
      *
-     * @param map          the HardwareMap
+     * @param map the HardwareMap
      * @param setStartPose the Pose to start from
      */
     public DriveEncoderLocalizer(HardwareMap map, Pose setStartPose) {
         hardwareMap = map;
 
-        leftFront = new Encoder(hardwareMap.get(DcMotorEx.class, FRONT_LEFT_MOTOR));
-        leftRear = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_LEFT_MOTOR));
-        rightRear = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_RIGHT_MOTOR));
-        rightFront = new Encoder(hardwareMap.get(DcMotorEx.class, FRONT_RIGHT_MOTOR));
-
-        DcMotor leftFrontDrive = hardwareMap.get(DcMotor.class, FRONT_LEFT_MOTOR);
-        DcMotor leftBackDrive = hardwareMap.get(DcMotor.class, BACK_LEFT_MOTOR);
-        DcMotor rightFrontDrive = hardwareMap.get(DcMotor.class, FRONT_RIGHT_MOTOR);
-        DcMotor rightBackDrive = hardwareMap.get(DcMotor.class, BACK_RIGHT_MOTOR);
-
-        leftFrontDrive.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
-        leftBackDrive.setDirection(BACK_LEFT_MOTOR_DIRECTION);
-        rightFrontDrive.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
-        rightBackDrive.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+        leftFront = new Encoder(hardwareMap.get(DcMotorEx.class, leftFrontMotorName));
+        leftRear = new Encoder(hardwareMap.get(DcMotorEx.class, leftRearMotorName));
+        rightRear = new Encoder(hardwareMap.get(DcMotorEx.class, rightRearMotorName));
+        rightFront = new Encoder(hardwareMap.get(DcMotorEx.class, rightFrontMotorName));
 
         // TODO: reverse any encoders necessary
-        leftFront.setDirection(FRONT_LEFT_MOTOR_ENCODER);
-        rightFront.setDirection(FRONT_RIGHT_MOTOR_ENCODER);
-        leftRear.setDirection(BACK_LEFT_MOTOR_ENCODER);
-        rightRear.setDirection(BACK_RIGHT_MOTOR_ENCODER);
+        leftFront.setDirection(Encoder.REVERSE);
+        rightRear.setDirection(Encoder.REVERSE);
+        leftRear.setDirection(Encoder.FORWARD);
+        rightRear.setDirection(Encoder.FORWARD);
 
         setStartPose(setStartPose);
         timer = new NanoTimer();
@@ -148,7 +129,7 @@ public class DriveEncoderLocalizer extends Localizer {
      * @param heading the rotation of the Matrix
      */
     public void setPrevRotationMatrix(double heading) {
-        prevRotationMatrix = new Matrix(3, 3);
+        prevRotationMatrix = new Matrix(3,3);
         prevRotationMatrix.set(0, 0, Math.cos(heading));
         prevRotationMatrix.set(0, 1, -Math.sin(heading));
         prevRotationMatrix.set(1, 0, Math.sin(heading));
@@ -183,7 +164,7 @@ public class DriveEncoderLocalizer extends Localizer {
         Matrix globalDeltas;
         setPrevRotationMatrix(getPose().getHeading());
 
-        Matrix transformation = new Matrix(3, 3);
+        Matrix transformation = new Matrix(3,3);
         if (Math.abs(robotDeltas.get(2, 0)) < 0.001) {
             transformation.set(0, 0, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
             transformation.set(0, 1, -robotDeltas.get(2, 0) / 2.0);
@@ -233,13 +214,13 @@ public class DriveEncoderLocalizer extends Localizer {
      * @return returns a Matrix containing the robot relative movement.
      */
     public Matrix getRobotDeltas() {
-        Matrix returnMatrix = new Matrix(3, 1);
+        Matrix returnMatrix = new Matrix(3,1);
         // x/forward movement
-        returnMatrix.set(0, 0, FORWARD_TICKS_TO_INCHES * (leftFront.getDeltaPosition() + rightFront.getDeltaPosition() + leftRear.getDeltaPosition() + rightRear.getDeltaPosition()));
+        returnMatrix.set(0,0, FORWARD_TICKS_TO_INCHES * (leftFront.getDeltaPosition() + rightFront.getDeltaPosition() + leftRear.getDeltaPosition() + rightRear.getDeltaPosition()));
         //y/strafe movement
-        returnMatrix.set(1, 0, STRAFE_TICKS_TO_INCHES * (-leftFront.getDeltaPosition() + rightFront.getDeltaPosition() + leftRear.getDeltaPosition() - rightRear.getDeltaPosition()));
+        returnMatrix.set(1,0, STRAFE_TICKS_TO_INCHES * (-leftFront.getDeltaPosition() + rightFront.getDeltaPosition() + leftRear.getDeltaPosition() - rightRear.getDeltaPosition()));
         // theta/turning
-        returnMatrix.set(2, 0, TURN_TICKS_TO_RADIANS * ((-leftFront.getDeltaPosition() + rightFront.getDeltaPosition() - leftRear.getDeltaPosition() + rightRear.getDeltaPosition()) / (ROBOT_WIDTH + ROBOT_LENGTH)));
+        returnMatrix.set(2,0, TURN_TICKS_TO_RADIANS * ((-leftFront.getDeltaPosition() + rightFront.getDeltaPosition() - leftRear.getDeltaPosition() + rightRear.getDeltaPosition()) / (ROBOT_WIDTH + ROBOT_LENGTH)));
         return returnMatrix;
     }
 

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/localizers/ThreeWheelIMULocalizer.java

@@ -0,0 +1,317 @@
+package org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.*;
+
+import com.acmerobotics.dashboard.config.Config;
+import com.qualcomm.hardware.rev.RevHubOrientationOnRobot;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+import com.qualcomm.robotcore.hardware.IMU;
+
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Localizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Matrix;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.MathFunctions;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Vector;
+import org.firstinspires.ftc.teamcode.pedroPathing.util.NanoTimer;
+
+/**
+ * This is the ThreeWheelIMULocalizer class. This class extends the Localizer superclass and is a
+ * localizer that uses the three wheel odometry set up with the IMU to have more accurate heading
+ * readings. The diagram below, which is modified from Road Runner, shows a typical set up.
+ *
+ * The view is from the top of the robot looking downwards.
+ *
+ * left on robot is the y positive direction
+ *
+ * forward on robot is the x positive direction
+ *
+ *    /--------------\
+ *    |     ____     |
+ *    |     ----     |
+ *    | ||        || |
+ *    | ||        || |  ----> left (y positive)
+ *    |              |
+ *    |              |
+ *    \--------------/
+ *           |
+ *           |
+ *           V
+ *    forward (x positive)
+ *
+ * @author Logan Nash
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @version 1.0, 7/9/2024
+ */
+@Config
+public class ThreeWheelIMULocalizer extends Localizer {
+    private HardwareMap hardwareMap;
+    private Pose startPose;
+    private Pose displacementPose;
+    private Pose currentVelocity;
+    private Matrix prevRotationMatrix;
+    private NanoTimer timer;
+    private long deltaTimeNano;
+    private Encoder leftEncoder;
+    private Encoder rightEncoder;
+    private Encoder strafeEncoder;
+    private Pose leftEncoderPose;
+    private Pose rightEncoderPose;
+    private Pose strafeEncoderPose;
+
+    public final IMU imu;
+    private double previousIMUOrientation;
+    private double deltaRadians;
+    private double totalHeading;
+    public static double FORWARD_TICKS_TO_INCHES = 0.004;//8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
+    public static double STRAFE_TICKS_TO_INCHES = -0.0036;//8192 * 1.37795 * 2 * Math.PI * 0.5018874659;
+    public static double TURN_TICKS_TO_RADIANS = 0.0043;//8192 * 1.37795 * 2 * Math.PI * 0.5;
+
+    public static boolean useIMU = true;
+
+    /**
+     * This creates a new ThreeWheelIMULocalizer from a HardwareMap, with a starting Pose at (0,0)
+     * facing 0 heading.
+     *
+     * @param map the HardwareMap
+     */
+    public ThreeWheelIMULocalizer(HardwareMap map) {
+        this(map, new Pose());
+    }
+
+    /**
+     * This creates a new ThreeWheelIMULocalizer from a HardwareMap and a Pose, with the Pose
+     * specifying the starting pose of the localizer.
+     *
+     * @param map          the HardwareMap
+     * @param setStartPose the Pose to start from
+     */
+    public ThreeWheelIMULocalizer(HardwareMap map, Pose setStartPose) {
+        hardwareMap = map;
+        imu = hardwareMap.get(IMU.class, IMU);
+
+        // TODO: replace this with your IMU's orientation
+        imu.initialize(new IMU.Parameters(new RevHubOrientationOnRobot(IMU_LOGO_FACING_DIRECTION, IMU_USB_FACING_DIRECTION)));
+
+        // TODO: replace these with your encoder positions
+        leftEncoderPose = new Pose(-7.625, 6.19375, 0);
+        rightEncoderPose = new Pose(-7.625, -6.19375, 0);
+        strafeEncoderPose = new Pose(7, 1, Math.toRadians(90));
+
+        // TODO: replace these with your encoder ports
+        leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+        rightEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, RIGHT_ENCODER));
+        strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+        // TODO: reverse any encoders necessary
+        leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+        rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+        strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+
+        setStartPose(setStartPose);
+        timer = new NanoTimer();
+        deltaTimeNano = 1;
+        displacementPose = new Pose();
+        currentVelocity = new Pose();
+        totalHeading = 0;
+
+        resetEncoders();
+    }
+
+    /**
+     * This returns the current pose estimate.
+     *
+     * @return returns the current pose estimate as a Pose
+     */
+    @Override
+    public Pose getPose() {
+        return MathFunctions.addPoses(startPose, displacementPose);
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Pose
+     */
+    @Override
+    public Pose getVelocity() {
+        return currentVelocity.copy();
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Vector
+     */
+    @Override
+    public Vector getVelocityVector() {
+        return currentVelocity.getVector();
+    }
+
+    /**
+     * This sets the start pose. Changing the start pose should move the robot as if all its
+     * previous movements were displacing it from its new start pose.
+     *
+     * @param setStart the new start pose
+     */
+    @Override
+    public void setStartPose(Pose setStart) {
+        startPose = setStart;
+    }
+
+    /**
+     * This sets the Matrix that contains the previous pose's heading rotation.
+     *
+     * @param heading the rotation of the Matrix
+     */
+    public void setPrevRotationMatrix(double heading) {
+        prevRotationMatrix = new Matrix(3,3);
+        prevRotationMatrix.set(0, 0, Math.cos(heading));
+        prevRotationMatrix.set(0, 1, -Math.sin(heading));
+        prevRotationMatrix.set(1, 0, Math.sin(heading));
+        prevRotationMatrix.set(1, 1, Math.cos(heading));
+        prevRotationMatrix.set(2, 2, 1.0);
+    }
+
+    /**
+     * This sets the current pose estimate. Changing this should just change the robot's current
+     * pose estimate, not anything to do with the start pose.
+     *
+     * @param setPose the new current pose estimate
+     */
+    @Override
+    public void setPose(Pose setPose) {
+        displacementPose = MathFunctions.subtractPoses(setPose, startPose);
+        resetEncoders();
+    }
+
+    /**
+     * This updates the elapsed time timer that keeps track of time between updates, as well as the
+     * change position of the Encoders. Then, the robot's global change in position is calculated
+     * using the pose exponential method.
+     */
+    @Override
+    public void update() {
+        deltaTimeNano = timer.getElapsedTime();
+        timer.resetTimer();
+
+        updateEncoders();
+        Matrix robotDeltas = getRobotDeltas();
+        Matrix globalDeltas;
+        setPrevRotationMatrix(getPose().getHeading());
+
+        Matrix transformation = new Matrix(3,3);
+        if (Math.abs(robotDeltas.get(2, 0)) < 0.001) {
+            transformation.set(0, 0, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(0, 1, -robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 0, robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 1, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(2, 2, 1.0);
+        } else {
+            transformation.set(0, 0, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(0, 1, (Math.cos(robotDeltas.get(2, 0)) - 1.0) / robotDeltas.get(2, 0));
+            transformation.set(1, 0, (1.0 - Math.cos(robotDeltas.get(2, 0))) / robotDeltas.get(2, 0));
+            transformation.set(1, 1, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(2, 2, 1.0);
+        }
+
+        globalDeltas = Matrix.multiply(Matrix.multiply(prevRotationMatrix, transformation), robotDeltas);
+
+        displacementPose.add(new Pose(globalDeltas.get(0, 0), globalDeltas.get(1, 0), globalDeltas.get(2, 0)));
+        currentVelocity = new Pose(globalDeltas.get(0, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(1, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(2, 0) / (deltaTimeNano * Math.pow(10.0, 9)));
+
+        totalHeading += globalDeltas.get(2, 0);
+    }
+
+    /**
+     * This updates the Encoders.
+     */
+    public void updateEncoders() {
+        leftEncoder.update();
+        rightEncoder.update();
+        strafeEncoder.update();
+
+        double currentIMUOrientation = MathFunctions.normalizeAngle(imu.getRobotYawPitchRollAngles().getYaw(AngleUnit.RADIANS));
+        deltaRadians = MathFunctions.getTurnDirection(previousIMUOrientation, currentIMUOrientation) * MathFunctions.getSmallestAngleDifference(currentIMUOrientation, previousIMUOrientation);
+        previousIMUOrientation = currentIMUOrientation;
+    }
+
+    /**
+     * This resets the Encoders.
+     */
+    public void resetEncoders() {
+        leftEncoder.reset();
+        rightEncoder.reset();
+        strafeEncoder.reset();
+    }
+
+    /**
+     * This calculates the change in position from the perspective of the robot using information
+     * from the Encoders.
+     *
+     * @return returns a Matrix containing the robot relative movement.
+     */
+    public Matrix getRobotDeltas() {
+        Matrix returnMatrix = new Matrix(3,1);
+        // x/forward movement
+        returnMatrix.set(0,0, FORWARD_TICKS_TO_INCHES * ((rightEncoder.getDeltaPosition() * leftEncoderPose.getY() - leftEncoder.getDeltaPosition() * rightEncoderPose.getY()) / (leftEncoderPose.getY() - rightEncoderPose.getY())));
+        //y/strafe movement
+        returnMatrix.set(1,0, STRAFE_TICKS_TO_INCHES * (strafeEncoder.getDeltaPosition() - strafeEncoderPose.getX() * ((rightEncoder.getDeltaPosition() - leftEncoder.getDeltaPosition()) / (leftEncoderPose.getY() - rightEncoderPose.getY()))));
+        // theta/turning
+        if (MathFunctions.getSmallestAngleDifference(0, deltaRadians) > 0.00005 && useIMU) {
+            returnMatrix.set(2, 0, deltaRadians);
+        } else {
+            returnMatrix.set(2,0, TURN_TICKS_TO_RADIANS * ((rightEncoder.getDeltaPosition() - leftEncoder.getDeltaPosition()) / (leftEncoderPose.getY() - rightEncoderPose.getY())));
+        }
+        return returnMatrix;
+    }
+
+    /**
+     * This returns how far the robot has turned in radians, in a number not clamped between 0 and
+     * 2 * pi radians. This is used for some tuning things and nothing actually within the following.
+     *
+     * @return returns how far the robot has turned in total, in radians.
+     */
+    public double getTotalHeading() {
+        return totalHeading;
+    }
+
+    /**
+     * This returns the multiplier applied to forward movement measurement to convert from encoder
+     * ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the forward ticks to inches multiplier
+     */
+    public double getForwardMultiplier() {
+        return FORWARD_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to lateral/strafe movement measurement to convert from
+     * encoder ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the lateral/strafe ticks to inches multiplier
+     */
+    public double getLateralMultiplier() {
+        return STRAFE_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to turning movement measurement to convert from encoder
+     * ticks to radians. This is found empirically through a tuner.
+     *
+     * @return returns the turning ticks to radians multiplier
+     */
+    public double getTurningMultiplier() {
+        return TURN_TICKS_TO_RADIANS;
+    }
+
+    /**
+     * This resets the IMU.
+     */
+    public void resetIMU() {
+        imu.resetYaw();
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/localizers/ThreeWheelLocalizer.java

@@ -0,0 +1,297 @@
+package org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.*;
+
+import com.acmerobotics.dashboard.config.Config;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Localizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Matrix;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.MathFunctions;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Vector;
+import org.firstinspires.ftc.teamcode.pedroPathing.util.NanoTimer;
+
+/**
+ * This is the ThreeWheelLocalizer class. This class extends the Localizer superclass and is a
+ * localizer that uses the three wheel odometry set up. The diagram below, which is modified from
+ * Road Runner, shows a typical set up.
+ *
+ * The view is from the top of the robot looking downwards.
+ *
+ * left on robot is the y positive direction
+ *
+ * forward on robot is the x positive direction
+ *
+ *    /--------------\
+ *    |     ____     |
+ *    |     ----     |
+ *    | ||        || |
+ *    | ||        || |  ----> left (y positive)
+ *    |              |
+ *    |              |
+ *    \--------------/
+ *           |
+ *           |
+ *           V
+ *    forward (x positive)
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @version 1.0, 4/2/2024
+ */
+@Config
+public class ThreeWheelLocalizer extends Localizer {
+    private HardwareMap hardwareMap;
+    private Pose startPose;
+    private Pose displacementPose;
+    private Pose currentVelocity;
+    private Matrix prevRotationMatrix;
+    private NanoTimer timer;
+    private long deltaTimeNano;
+    private Encoder leftEncoder;
+    private Encoder rightEncoder;
+    private Encoder strafeEncoder;
+    private Pose leftEncoderPose;
+    private Pose rightEncoderPose;
+    private Pose strafeEncoderPose;
+    private double totalHeading;
+//    public static double FORWARD_TICKS_TO_INCHES = 0.00052189;//8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
+    public static double FORWARD_TICKS_TO_INCHES = 0.0029;//8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
+//    public static double STRAFE_TICKS_TO_INCHES = 0.00052189;//8192 * 1.37795 * 2 * Math.PI * 0.5018874659;
+    public static double STRAFE_TICKS_TO_INCHES = 0.0029;//8192 * 1.37795 * 2 * Math.PI * 0.5018874659;
+//    public static double TURN_TICKS_TO_RADIANS = 0.00053717;//8192 * 1.37795 * 2 * Math.PI * 0.5;
+    public static double TURN_TICKS_TO_RADIANS = 0.003;//8192 * 1.37795 * 2 * Math.PI * 0.5;
+
+    /**
+     * This creates a new ThreeWheelLocalizer from a HardwareMap, with a starting Pose at (0,0)
+     * facing 0 heading.
+     *
+     * @param map the HardwareMap
+     */
+    public ThreeWheelLocalizer(HardwareMap map) {
+        this(map, new Pose());
+    }
+
+    /**
+     * This creates a new ThreeWheelLocalizer from a HardwareMap and a Pose, with the Pose
+     * specifying the starting pose of the localizer.
+     *
+     * @param map the HardwareMap
+     * @param setStartPose the Pose to start from
+     */
+    public ThreeWheelLocalizer(HardwareMap map, Pose setStartPose) {
+        // TODO: replace these with your encoder positions
+        leftEncoderPose = new Pose(0, 6.19375, 0);
+        rightEncoderPose = new Pose(0, -6.19375, 0);
+        strafeEncoderPose = new Pose(-7, 0, Math.toRadians(90));
+
+        hardwareMap = map;
+
+        // TODO: replace these with your encoder ports
+        leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+        rightEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, RIGHT_ENCODER));
+        strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+        // TODO: reverse any encoders necessary
+        leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+        rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+        strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+
+        setStartPose(setStartPose);
+        timer = new NanoTimer();
+        deltaTimeNano = 1;
+        displacementPose = new Pose();
+        currentVelocity = new Pose();
+        totalHeading = 0;
+
+        resetEncoders();
+    }
+
+    /**
+     * This returns the current pose estimate.
+     *
+     * @return returns the current pose estimate as a Pose
+     */
+    @Override
+    public Pose getPose() {
+        return MathFunctions.addPoses(startPose, displacementPose);
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Pose
+     */
+    @Override
+    public Pose getVelocity() {
+        return currentVelocity.copy();
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Vector
+     */
+    @Override
+    public Vector getVelocityVector() {
+        return currentVelocity.getVector();
+    }
+
+    /**
+     * This sets the start pose. Changing the start pose should move the robot as if all its
+     * previous movements were displacing it from its new start pose.
+     *
+     * @param setStart the new start pose
+     */
+    @Override
+    public void setStartPose(Pose setStart) {
+        startPose = setStart;
+    }
+
+    /**
+     * This sets the Matrix that contains the previous pose's heading rotation.
+     *
+     * @param heading the rotation of the Matrix
+     */
+    public void setPrevRotationMatrix(double heading) {
+        prevRotationMatrix = new Matrix(3,3);
+        prevRotationMatrix.set(0, 0, Math.cos(heading));
+        prevRotationMatrix.set(0, 1, -Math.sin(heading));
+        prevRotationMatrix.set(1, 0, Math.sin(heading));
+        prevRotationMatrix.set(1, 1, Math.cos(heading));
+        prevRotationMatrix.set(2, 2, 1.0);
+    }
+
+    /**
+     * This sets the current pose estimate. Changing this should just change the robot's current
+     * pose estimate, not anything to do with the start pose.
+     *
+     * @param setPose the new current pose estimate
+     */
+    @Override
+    public void setPose(Pose setPose) {
+        displacementPose = MathFunctions.subtractPoses(setPose, startPose);
+        resetEncoders();
+    }
+
+    /**
+     * This updates the elapsed time timer that keeps track of time between updates, as well as the
+     * change position of the Encoders. Then, the robot's global change in position is calculated
+     * using the pose exponential method.
+     */
+    @Override
+    public void update() {
+        deltaTimeNano = timer.getElapsedTime();
+        timer.resetTimer();
+
+        updateEncoders();
+        Matrix robotDeltas = getRobotDeltas();
+        Matrix globalDeltas;
+        setPrevRotationMatrix(getPose().getHeading());
+
+        Matrix transformation = new Matrix(3,3);
+        if (Math.abs(robotDeltas.get(2, 0)) < 0.001) {
+            transformation.set(0, 0, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(0, 1, -robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 0, robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 1, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(2, 2, 1.0);
+        } else {
+            transformation.set(0, 0, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(0, 1, (Math.cos(robotDeltas.get(2, 0)) - 1.0) / robotDeltas.get(2, 0));
+            transformation.set(1, 0, (1.0 - Math.cos(robotDeltas.get(2, 0))) / robotDeltas.get(2, 0));
+            transformation.set(1, 1, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(2, 2, 1.0);
+        }
+
+        globalDeltas = Matrix.multiply(Matrix.multiply(prevRotationMatrix, transformation), robotDeltas);
+
+        displacementPose.add(new Pose(globalDeltas.get(0, 0), globalDeltas.get(1, 0), globalDeltas.get(2, 0)));
+        currentVelocity = new Pose(globalDeltas.get(0, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(1, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(2, 0) / (deltaTimeNano * Math.pow(10.0, 9)));
+
+        totalHeading += globalDeltas.get(2, 0);
+    }
+
+    /**
+     * This updates the Encoders.
+     */
+    public void updateEncoders() {
+        leftEncoder.update();
+        rightEncoder.update();
+        strafeEncoder.update();
+    }
+
+    /**
+     * This resets the Encoders.
+     */
+    public void resetEncoders() {
+        leftEncoder.reset();
+        rightEncoder.reset();
+        strafeEncoder.reset();
+    }
+
+    /**
+     * This calculates the change in position from the perspective of the robot using information
+     * from the Encoders.
+     *
+     * @return returns a Matrix containing the robot relative movement.
+     */
+    public Matrix getRobotDeltas() {
+        Matrix returnMatrix = new Matrix(3,1);
+        // x/forward movement
+        returnMatrix.set(0,0, FORWARD_TICKS_TO_INCHES * ((rightEncoder.getDeltaPosition() * leftEncoderPose.getY() - leftEncoder.getDeltaPosition() * rightEncoderPose.getY()) / (leftEncoderPose.getY() - rightEncoderPose.getY())));
+        //y/strafe movement
+        returnMatrix.set(1,0, STRAFE_TICKS_TO_INCHES * (strafeEncoder.getDeltaPosition() - strafeEncoderPose.getX() * ((rightEncoder.getDeltaPosition() - leftEncoder.getDeltaPosition()) / (leftEncoderPose.getY() - rightEncoderPose.getY()))));
+        // theta/turning
+        returnMatrix.set(2,0, TURN_TICKS_TO_RADIANS * ((rightEncoder.getDeltaPosition() - leftEncoder.getDeltaPosition()) / (leftEncoderPose.getY() - rightEncoderPose.getY())));
+        return returnMatrix;
+    }
+
+    /**
+     * This returns how far the robot has turned in radians, in a number not clamped between 0 and
+     * 2 * pi radians. This is used for some tuning things and nothing actually within the following.
+     *
+     * @return returns how far the robot has turned in total, in radians.
+     */
+    public double getTotalHeading() {
+        return totalHeading;
+    }
+
+    /**
+     * This returns the multiplier applied to forward movement measurement to convert from encoder
+     * ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the forward ticks to inches multiplier
+     */
+    public double getForwardMultiplier() {
+        return FORWARD_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to lateral/strafe movement measurement to convert from
+     * encoder ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the lateral/strafe ticks to inches multiplier
+     */
+    public double getLateralMultiplier() {
+        return STRAFE_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to turning movement measurement to convert from encoder
+     * ticks to radians. This is found empirically through a tuner.
+     *
+     * @return returns the turning ticks to radians multiplier
+     */
+    public double getTurningMultiplier() {
+        return TURN_TICKS_TO_RADIANS;
+    }
+
+    /**
+     * This does nothing since this localizer does not use the IMU.
+     */
+    public void resetIMU() {
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/localizers/TwoWheelLocalizer.java

@@ -0,0 +1,302 @@
+package org.firstinspires.ftc.teamcode.pedroPathing.localization.localizers;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+
+import com.acmerobotics.dashboard.config.Config;
+import com.qualcomm.hardware.rev.RevHubOrientationOnRobot;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+import com.qualcomm.robotcore.hardware.IMU;
+
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Localizer;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Matrix;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.MathFunctions;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Vector;
+import org.firstinspires.ftc.teamcode.pedroPathing.util.NanoTimer;
+
+/**
+ * This is the TwoWheelLocalizer class. This class extends the Localizer superclass and is a
+ * localizer that uses the two wheel odometry with IMU set up. The diagram below, which is modified from
+ * Road Runner, shows a typical set up.
+ *
+ * The view is from the top of the robot looking downwards.
+ *
+ * left on robot is the y positive direction
+ *
+ * forward on robot is the x positive direction
+ *
+ *    /--------------\
+ *    |     ____     |
+ *    |     ----     |
+ *    | ||        || |
+ *    | ||        || |  ----> left (y positive)
+ *    |              |
+ *    |              |
+ *    \--------------/
+ *           |
+ *           |
+ *           V
+ *    forward (x positive)
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @version 1.0, 4/2/2024
+ */
+@Config
+public class TwoWheelLocalizer extends Localizer { // todo: make two wheel odo work
+    private HardwareMap hardwareMap;
+    private IMU imu;
+    private Pose startPose;
+    private Pose displacementPose;
+    private Pose currentVelocity;
+    private Matrix prevRotationMatrix;
+    private NanoTimer timer;
+    private long deltaTimeNano;
+    private Encoder forwardEncoder;
+    private Encoder strafeEncoder;
+    private Pose forwardEncoderPose;
+    private Pose strafeEncoderPose;
+    private double previousIMUOrientation;
+    private double deltaRadians;
+    private double totalHeading;
+    public static double FORWARD_TICKS_TO_INCHES = 8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
+    public static double STRAFE_TICKS_TO_INCHES = 8192 * 1.37795 * 2 * Math.PI * 0.5018874659;
+
+    /**
+     * This creates a new TwoWheelLocalizer from a HardwareMap, with a starting Pose at (0,0)
+     * facing 0 heading.
+     *
+     * @param map the HardwareMap
+     */
+    public TwoWheelLocalizer(HardwareMap map) {
+        this(map, new Pose());
+    }
+
+    /**
+     * This creates a new TwoWheelLocalizer from a HardwareMap and a Pose, with the Pose
+     * specifying the starting pose of the localizer.
+     *
+     * @param map the HardwareMap
+     * @param setStartPose the Pose to start from
+     */
+    public TwoWheelLocalizer(HardwareMap map, Pose setStartPose) {
+        // TODO: replace these with your encoder positions
+        forwardEncoderPose = new Pose(-18.5/25.4 - 0.1, 164.4/25.4, 0);
+        strafeEncoderPose = new Pose(-107.9/25.4+0.25, -1.1/25.4-0.23, Math.toRadians(90));
+
+        hardwareMap = map;
+
+        imu = hardwareMap.get(IMU.class, "imu");
+        // TODO: replace this with your IMU's orientation
+        imu.initialize(new IMU.Parameters(new RevHubOrientationOnRobot(RevHubOrientationOnRobot.LogoFacingDirection.UP, RevHubOrientationOnRobot.UsbFacingDirection.LEFT)));
+
+        // TODO: replace these with your encoder ports
+        forwardEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+        strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+        // TODO: reverse any encoders necessary
+        forwardEncoder.setDirection(Encoder.REVERSE);
+        strafeEncoder.setDirection(Encoder.FORWARD);
+
+        setStartPose(setStartPose);
+        timer = new NanoTimer();
+        deltaTimeNano = 1;
+        displacementPose = new Pose();
+        currentVelocity = new Pose();
+
+        previousIMUOrientation = MathFunctions.normalizeAngle(imu.getRobotYawPitchRollAngles().getYaw(AngleUnit.RADIANS));
+        deltaRadians = 0;
+    }
+
+    /**
+     * This returns the current pose estimate.
+     *
+     * @return returns the current pose estimate as a Pose
+     */
+    @Override
+    public Pose getPose() {
+        return MathFunctions.addPoses(startPose, displacementPose);
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Pose
+     */
+    @Override
+    public Pose getVelocity() {
+        return currentVelocity.copy();
+    }
+
+    /**
+     * This returns the current velocity estimate.
+     *
+     * @return returns the current velocity estimate as a Vector
+     */
+    @Override
+    public Vector getVelocityVector() {
+        return currentVelocity.getVector();
+    }
+
+    /**
+     * This sets the start pose. Changing the start pose should move the robot as if all its
+     * previous movements were displacing it from its new start pose.
+     *
+     * @param setStart the new start pose
+     */
+    @Override
+    public void setStartPose(Pose setStart) {
+        startPose = setStart;
+    }
+
+    /**
+     * This sets the Matrix that contains the previous pose's heading rotation.
+     *
+     * @param heading the rotation of the Matrix
+     */
+    public void setPrevRotationMatrix(double heading) {
+        prevRotationMatrix = new Matrix(3,3);
+        prevRotationMatrix.set(0, 0, Math.cos(heading));
+        prevRotationMatrix.set(0, 1, -Math.sin(heading));
+        prevRotationMatrix.set(1, 0, Math.sin(heading));
+        prevRotationMatrix.set(1, 1, Math.cos(heading));
+        prevRotationMatrix.set(2, 2, 1.0);
+    }
+
+    /**
+     * This sets the current pose estimate. Changing this should just change the robot's current
+     * pose estimate, not anything to do with the start pose.
+     *
+     * @param setPose the new current pose estimate
+     */
+    @Override
+    public void setPose(Pose setPose) {
+        displacementPose = MathFunctions.subtractPoses(setPose, startPose);
+        resetEncoders();
+    }
+
+    /**
+     * This updates the elapsed time timer that keeps track of time between updates, as well as the
+     * change position of the Encoders and the IMU readings. Then, the robot's global change in
+     * position is calculated using the pose exponential method.
+     */
+    @Override
+    public void update() {
+        deltaTimeNano = timer.getElapsedTime();
+        timer.resetTimer();
+
+        updateEncoders();
+        Matrix robotDeltas = getRobotDeltas();
+        Matrix globalDeltas;
+        setPrevRotationMatrix(getPose().getHeading());
+
+        Matrix transformation = new Matrix(3,3);
+        if (Math.abs(robotDeltas.get(2, 0)) < 0.001) {
+            transformation.set(0, 0, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(0, 1, -robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 0, robotDeltas.get(2, 0) / 2.0);
+            transformation.set(1, 1, 1.0 - (Math.pow(robotDeltas.get(2, 0), 2) / 6.0));
+            transformation.set(2, 2, 1.0);
+        } else {
+            transformation.set(0, 0, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(0, 1, (Math.cos(robotDeltas.get(2, 0)) - 1.0) / robotDeltas.get(2, 0));
+            transformation.set(1, 0, (1.0 - Math.cos(robotDeltas.get(2, 0))) / robotDeltas.get(2, 0));
+            transformation.set(1, 1, Math.sin(robotDeltas.get(2, 0)) / robotDeltas.get(2, 0));
+            transformation.set(2, 2, 1.0);
+        }
+
+        globalDeltas = Matrix.multiply(Matrix.multiply(prevRotationMatrix, transformation), robotDeltas);
+
+        displacementPose.add(new Pose(globalDeltas.get(0, 0), globalDeltas.get(1, 0), globalDeltas.get(2, 0)));
+        currentVelocity = new Pose(globalDeltas.get(0, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(1, 0) / (deltaTimeNano * Math.pow(10.0, 9)), globalDeltas.get(2, 0) / (deltaTimeNano * Math.pow(10.0, 9)));
+
+        totalHeading += globalDeltas.get(2, 0);
+    }
+
+    /**
+     * This updates the Encoders as well as the IMU.
+     */
+    public void updateEncoders() {
+        forwardEncoder.update();
+        strafeEncoder.update();
+
+        double currentIMUOrientation = MathFunctions.normalizeAngle(imu.getRobotYawPitchRollAngles().getYaw(AngleUnit.RADIANS));
+        deltaRadians = MathFunctions.getTurnDirection(previousIMUOrientation, currentIMUOrientation) * MathFunctions.getSmallestAngleDifference(currentIMUOrientation, previousIMUOrientation);
+        previousIMUOrientation = currentIMUOrientation;
+    }
+
+    /**
+     * This resets the Encoders.
+     */
+    public void resetEncoders() {
+        forwardEncoder.reset();
+        strafeEncoder.reset();
+    }
+
+    /**
+     * This calculates the change in position from the perspective of the robot using information
+     * from the Encoders and IMU.
+     *
+     * @return returns a Matrix containing the robot relative movement.
+     */
+    public Matrix getRobotDeltas() {
+        Matrix returnMatrix = new Matrix(3,1);
+        // x/forward movement
+        returnMatrix.set(0,0, FORWARD_TICKS_TO_INCHES * (forwardEncoder.getDeltaPosition() - forwardEncoderPose.getY() * deltaRadians));
+        //y/strafe movement
+        returnMatrix.set(1,0, STRAFE_TICKS_TO_INCHES * (strafeEncoder.getDeltaPosition() - strafeEncoderPose.getX() * deltaRadians));
+        // theta/turning
+        returnMatrix.set(2,0, deltaRadians);
+        return returnMatrix;
+    }
+
+    /**
+     * This returns how far the robot has turned in radians, in a number not clamped between 0 and
+     * 2 * pi radians. This is used for some tuning things and nothing actually within the following.
+     *
+     * @return returns how far the robot has turned in total, in radians.
+     */
+    public double getTotalHeading() {
+        return totalHeading;
+    }
+
+    /**
+     * This returns the multiplier applied to forward movement measurement to convert from encoder
+     * ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the forward ticks to inches multiplier
+     */
+    public double getForwardMultiplier() {
+        return FORWARD_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to lateral/strafe movement measurement to convert from
+     * encoder ticks to inches. This is found empirically through a tuner.
+     *
+     * @return returns the lateral/strafe ticks to inches multiplier
+     */
+    public double getLateralMultiplier() {
+        return STRAFE_TICKS_TO_INCHES;
+    }
+
+    /**
+     * This returns the multiplier applied to turning movement measurement to convert from encoder
+     * ticks to radians. This is found empirically through a tuner.
+     *
+     * @return returns the turning ticks to radians multiplier
+     */
+    public double getTurningMultiplier() {
+        return 1;
+    }
+
+    /**
+     * This resets the IMU.
+     */
+    public void resetIMU() {
+        imu.resetYaw();
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/localization/tuning/LocalizationTest.java

@@ -58,6 +58,9 @@ public class LocalizationTest extends OpMode {
         rightRear = hardwareMap.get(DcMotorEx.class, rightRearMotorName);
         rightFront = hardwareMap.get(DcMotorEx.class, rightFrontMotorName);
 
+        leftFront.setDirection(DcMotorSimple.Direction.REVERSE);
+        leftRear.setDirection(DcMotorSimple.Direction.REVERSE);
+
         motors = Arrays.asList(leftFront, leftRear, rightFront, rightRear);
 
         for (DcMotorEx motor : motors) {

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/pedroPathing/tuning/FollowerConstants.java

@@ -42,7 +42,7 @@ public class FollowerConstants {
     public static CustomPIDFCoefficients translationalPIDFCoefficients = new CustomPIDFCoefficients(
             0.1,
             0,
-            0,
+            0.01,
             0);
 
     // Translational Integral
@@ -58,9 +58,9 @@ public class FollowerConstants {
 
     // Heading error PIDF coefficients
     public static CustomPIDFCoefficients headingPIDFCoefficients = new CustomPIDFCoefficients(
-            1,
-            0,
+            2,
             0,
+            .025,
             0);
 
     // Feed forward constant added on to the heading PIDF
@@ -69,10 +69,10 @@ public class FollowerConstants {
 
     // Drive PIDF coefficients
     public static CustomFilteredPIDFCoefficients drivePIDFCoefficients = new CustomFilteredPIDFCoefficients(
-            0.025,
+            0.006,
             0,
             0.00001,
-            0.6,
+            0.8,
             0);
 
     // Feed forward constant added on to the drive PIDF
@@ -81,7 +81,7 @@ public class FollowerConstants {
     // Kalman filter parameters for the drive error Kalman filter
     public static KalmanFilterParameters driveKalmanFilterParameters = new KalmanFilterParameters(
             6,
-            1);
+            3);
 
 
     // Mass of robot in kilograms
@@ -202,9 +202,9 @@ public class FollowerConstants {
 
     // Secondary drive PIDF coefficients
     public static CustomFilteredPIDFCoefficients secondaryDrivePIDFCoefficients = new CustomFilteredPIDFCoefficients(
-            0.00315,
+            0.02,
             0,
-            0.0001,
+            0.000005,
             0.6,
             0);
 

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/runmodes/Auto.java

@@ -0,0 +1,114 @@
+package org.firstinspires.ftc.teamcode.runmodes;
+
+import com.qualcomm.robotcore.hardware.HardwareMap;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Path;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+import org.firstinspires.ftc.teamcode.pedroPathing.util.Timer;
+import org.firstinspires.ftc.teamcode.subsystem.ArmSubsystem;
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+import static org.firstinspires.ftc.teamcode.util.action.FieldConstants.*;
+
+import org.firstinspires.ftc.teamcode.subsystem.WristSubsystem;
+import org.firstinspires.ftc.teamcode.util.action.Action;
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+import org.firstinspires.ftc.teamcode.util.action.SequentialAction;
+import org.firstinspires.ftc.teamcode.util.action.SleepAction;
+
+public class Auto {
+
+    public ClawSubsystem claw;
+    public ArmSubsystem arm;
+    public WristSubsystem wrist;
+
+    public Timer clawTimer = new Timer();
+    public Timer armTimer = new Timer();
+    public Timer wristTimer = new Timer();
+
+    public Follower follower;
+    public Telemetry telemetry;
+
+    public int caseState = 1;
+
+    public Auto(HardwareMap hardwareMap, Telemetry telemetry, Follower follower) {
+        claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.CLOSED);
+        arm = new ArmSubsystem(hardwareMap, ArmSubsystem.ArmState.PARK);
+        wrist = new WristSubsystem(hardwareMap, WristSubsystem.WristState.FLOOR);
+
+        this.follower = follower;
+        this.telemetry = telemetry;
+
+        init();
+    }
+
+    public void init() {
+        claw.init();
+        arm.init();
+        wrist.init();
+    }
+
+    public void start() {
+        clawTimer.resetTimer();
+        armTimer.resetTimer();
+        wristTimer.resetTimer();
+
+        claw.start();
+        arm.start();
+        wrist.start();
+    }
+
+    public void update() {
+
+        this.telemetry.addData("Current State", caseState);
+        this.telemetry.addData("Claw Timer", clawTimer.getElapsedTimeSeconds());
+        this.telemetry.addData("Arm Timer", armTimer.getElapsedTimeSeconds());
+        this.telemetry.addData("Wrist Timer", wristTimer.getElapsedTimeSeconds());
+        this.telemetry.update();
+
+        switch(caseState) {
+            case 1:
+                claw.openClaw();
+                caseState = 2;
+                break;
+            case 2:
+                if (clawTimer.getElapsedTimeSeconds() > 2) {
+                    arm.engageArm();
+                    caseState = 3;
+                }
+                break;
+            case 3:
+                if (armTimer.getElapsedTimeSeconds() > 4) {
+                    wrist.floorWrist();
+                    caseState = 4;
+                }
+                break;
+            case 4:
+                if (clawTimer.getElapsedTimeSeconds() > 6) {
+                    claw.closeClaw();
+                    caseState = 5;
+                }
+                break;
+            case 5:
+                if (armTimer.getElapsedTimeSeconds() > 8) {
+                    arm.bucketArm();
+                    wrist.bucketWrist();
+                    caseState = 6;
+                }
+                break;
+            case 6:
+                if (clawTimer.getElapsedTimeSeconds() > 10) {
+                    claw.openClaw();
+                    caseState = 7;
+                }
+                break;
+            case 7:
+                this.init();
+                break;
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/runmodes/Teleop.java

@@ -0,0 +1,89 @@
+package org.firstinspires.ftc.teamcode.runmodes;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
+
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.subsystem.ClawSubsystem;
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+
+public class Teleop {
+
+    private ClawSubsystem claw;
+    private Follower follower;
+    private DcMotorEx leftFront;
+    private DcMotorEx leftRear;
+    private DcMotorEx rightFront;
+    private DcMotorEx rightRear;
+    private Telemetry telemetry;
+
+    private Gamepad gamepad1;
+    private Gamepad currentGamepad1;
+    private Gamepad previousGamepad1;
+
+    public Teleop(HardwareMap hardwareMap, Telemetry telemetry, Follower follower, Gamepad gamepad1) {
+
+        claw = new ClawSubsystem(hardwareMap, ClawSubsystem.ClawState.CLOSED);
+        initMotors(hardwareMap);
+
+        this.follower = follower;
+
+        this.telemetry = telemetry;
+        this.gamepad1 = gamepad1;
+
+        this.currentGamepad1 = new Gamepad();
+        this.previousGamepad1 = new Gamepad();
+    }
+
+    public void start() {
+        claw.start();
+        follower.startTeleopDrive();
+    }
+
+    public void update() {
+        previousGamepad1.copy(currentGamepad1);
+        currentGamepad1.copy(gamepad1);
+
+        if (currentGamepad1.a && !previousGamepad1.a)
+            claw.switchState();
+
+        follower.setTeleOpMovementVectors(-gamepad1.left_stick_y, -gamepad1.left_stick_x, -gamepad1.right_stick_x);
+        follower.update();
+
+        telemetry.addData("X", follower.getPose().getX());
+        telemetry.addData("Y", follower.getPose().getY());
+        telemetry.addData("Heading", Math.toDegrees(follower.getPose().getHeading()));
+        telemetry.addData("Claw State", claw.getState());
+        telemetry.update();
+    }
+
+    private void initMotors(HardwareMap hardwareMap) {
+        rightFront = hardwareMap.get(DcMotorEx.class, FRONT_RIGHT_MOTOR);
+        rightRear = hardwareMap.get(DcMotorEx.class, BACK_RIGHT_MOTOR);
+        leftFront = hardwareMap.get(DcMotorEx.class, FRONT_LEFT_MOTOR);
+        leftRear = hardwareMap.get(DcMotorEx.class, BACK_LEFT_MOTOR);
+
+        rightFront.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
+        rightRear.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+        leftFront.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
+        leftRear.setDirection(BACK_LEFT_MOTOR_DIRECTION);
+
+        leftFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        leftRear.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        rightRear.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        rightFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/subsystem/ArmSubsystem.java

@@ -0,0 +1,89 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.armEngage;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.armPark;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.armBucket;
+
+import com.qualcomm.robotcore.hardware.HardwareMap;
+import com.qualcomm.robotcore.hardware.ServoImplEx;
+
+import org.firstinspires.ftc.teamcode.util.action.Actions;
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+
+public class ArmSubsystem {
+
+    public enum ArmState {
+        PARK, ENGAGE, BUCKET
+    }
+
+    public ServoImplEx arm;
+    public ArmState state;
+    public RunAction engageArm, parkArm, bucketArm;
+
+    public ArmSubsystem(HardwareMap hardwareMap, ArmState armState) {
+        arm = hardwareMap.get(ServoImplEx.class, "arm-servo");
+        arm.resetDeviceConfigurationForOpMode();
+
+        this.state = armState;
+
+        parkArm = new RunAction(this::parkArm);
+        engageArm = new RunAction(this::engageArm);
+        bucketArm = new RunAction(this::bucketArm);
+    }
+
+    public void setState(ArmState armState) {
+        if (armState == ArmState.ENGAGE) {
+            arm.setPosition(armEngage);
+            this.state = ArmState.ENGAGE;
+        } else if (armState == ArmState.PARK) {
+            arm.setPosition(armPark);
+            this.state = ArmState.PARK;
+        } else if (armState == ArmState.BUCKET) {
+            arm.setPosition(armBucket);
+            this.state = ArmState.BUCKET;
+        }
+    }
+
+    public void engageArm() {
+        setState(ArmState.ENGAGE);
+    }
+
+    public void parkArm() {
+        setState(ArmState.PARK);
+    }
+
+    public void bucketArm() {
+        setState(ArmState.BUCKET);
+    }
+
+    public void switchState() {
+        if (state == ArmState.ENGAGE) {
+            setState(ArmState.PARK);
+        } else if (state == ArmState.PARK) {
+            setState(ArmState.BUCKET);
+        } else if (state == ArmState.BUCKET) {
+            setState(ArmState.ENGAGE);
+        }
+    }
+
+    public ArmState getState() {
+        return this.state;
+    }
+
+    public void init() {
+        Actions.runBlocking(parkArm);
+    }
+
+    public void start() {
+        Actions.runBlocking(parkArm);
+    }
+
+    public double getPosition() {
+        return this.arm.getPosition();
+    }
+
+    public void setPosition(double position) {
+        this.arm.setPosition(position);
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/subsystem/ClawSubsystem.java

@@ -0,0 +1,67 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import com.qualcomm.robotcore.hardware.HardwareMap;
+import com.qualcomm.robotcore.hardware.Servo;
+
+import org.firstinspires.ftc.teamcode.util.action.Actions;
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.clawOpen;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.clawClose;
+
+public class ClawSubsystem {
+
+    public enum ClawState {
+        CLOSED, OPEN
+    }
+
+    private Servo claw;
+    private ClawState state;
+    public RunAction openClaw, closeClaw;
+
+    public ClawSubsystem(HardwareMap hardwareMap, ClawState clawState) {
+        claw = hardwareMap.get(Servo.class, "claw-servo");
+        this.state = clawState;
+
+        openClaw = new RunAction(this::openClaw);
+        closeClaw = new RunAction(this::closeClaw);
+    }
+
+    public void setState(ClawState clawState) {
+        if (clawState == ClawState.CLOSED) {
+            claw.setPosition(clawClose);
+            this.state = ClawState.CLOSED;
+        } else if (clawState == ClawState.OPEN) {
+            claw.setPosition(clawOpen);
+            this.state = ClawState.OPEN;
+        }
+    }
+
+    public ClawState getState() {
+        return this.state;
+    }
+
+    public void switchState() {
+        if (state == ClawState.CLOSED) {
+            setState(ClawState.OPEN);
+        } else if (state == ClawState.OPEN) {
+            setState(ClawState.CLOSED);
+        }
+    }
+
+    public void openClaw() {
+        setState(ClawState.OPEN);
+    }
+
+    public void closeClaw() {
+        setState(ClawState.CLOSED);
+    }
+
+    public void init() {
+        Actions.runBlocking(closeClaw);
+    }
+
+    public void start() {
+        Actions.runBlocking(closeClaw);
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/subsystem/LiftSubsystem.java

@@ -0,0 +1,94 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftPower;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftToFloatPos;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftToFloorPos;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftToHighBucketPos;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftToLowBucketPos;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.liftToHoverState;
+
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.DcMotorSimple;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+
+public class LiftSubsystem {
+
+    public DcMotor lift;
+    public RunAction toFloor, toLowBucket, toHighBucket;
+
+    public enum LiftState {
+        FLOOR, LOW_BUCKET, HIGH_BUCKET, FLOAT, HOVER
+    }
+
+    private LiftState liftState;
+
+    public LiftSubsystem(HardwareMap hardwareMap) {
+        lift = hardwareMap.get(DcMotor.class, "lift-motor");
+        toFloor = new RunAction(this::toFloor);
+        toLowBucket = new RunAction(this::toLowBucket);
+        toHighBucket = new RunAction(this::toHighBucket);
+    }
+
+    public void setTarget(int b) {
+        lift.setTargetPosition(b);
+        lift.setMode(DcMotor.RunMode.RUN_TO_POSITION);
+    }
+
+    public void switchState() {
+        if (this.liftState == LiftState.FLOOR) {
+            this.toFloor();
+        } else if (this.liftState == LiftState.FLOAT) {
+            this.toLowBucket();
+        } else if (this.liftState == LiftState.LOW_BUCKET) {
+            this.toHighBucket();
+        } else if (this.liftState == LiftState.HIGH_BUCKET) {
+            this.toFloor();
+        }
+    }
+
+     public void toHover() {
+        this.setTarget(liftToHoverState);
+        this.setState(LiftState.HOVER);
+    }
+
+    public void toFloor() {
+        this.setTarget(liftToFloorPos);
+        this.setState(LiftState.FLOOR);
+    }
+
+    public void toFloat() {
+        this.setTarget(liftToFloatPos);
+        this.setState(LiftState.FLOAT);
+    }
+
+    public void toLowBucket() {
+        this.setTarget(liftToLowBucketPos);
+        this.setState(LiftState.LOW_BUCKET);
+    }
+
+    public void toHighBucket() {
+        this.setTarget(liftToHighBucketPos);
+        this.setState(LiftState.HIGH_BUCKET);
+    }
+
+    public void init() {
+        lift.setMode(DcMotor.RunMode.STOP_AND_RESET_ENCODER);
+        lift.setDirection(DcMotorSimple.Direction.REVERSE);
+        lift.setPower(liftPower);
+    }
+
+    private void setState(LiftState liftState) {
+        this.liftState = liftState;
+    }
+
+    public int getPosition() {
+        return lift.getCurrentPosition();
+    }
+
+    public void start() {
+        this.toFloor();
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/subsystem/MotorsSubsystem.java

@@ -0,0 +1,130 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
+
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.Gamepad;
+import com.qualcomm.robotcore.hardware.HardwareMap;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+
+public class MotorsSubsystem {
+
+    public HardwareMap hardwareMap;
+    public Telemetry telemetry;
+
+    public DcMotor frontLeftMotor;
+    public DcMotor backLeftMotor;
+    public DcMotor frontRightMotor;
+    public DcMotor backRightMotor;
+
+    public enum TravelState {
+        PARKED, BUCKET, SUBMARINE
+    }
+
+    public TravelState travelState;
+
+    public double power;
+
+    public MotorsSubsystem(HardwareMap hardwareMap, Telemetry telemetry) {
+        this.hardwareMap = hardwareMap;
+        this.telemetry = telemetry;
+        this.power = 1.0;
+    }
+
+    public MotorsSubsystem(HardwareMap hardwareMap, Telemetry telemetry, double power) {
+        this.hardwareMap = hardwareMap;
+        this.telemetry = telemetry;
+        this.power = power;
+    }
+
+    public void init() {
+        frontLeftMotor = hardwareMap.get(DcMotor.class, FRONT_LEFT_MOTOR);
+        backLeftMotor = hardwareMap.get(DcMotor.class, BACK_LEFT_MOTOR);
+        frontRightMotor = hardwareMap.get(DcMotor.class, FRONT_RIGHT_MOTOR);
+        backRightMotor = hardwareMap.get(DcMotor.class, BACK_RIGHT_MOTOR);
+
+        frontLeftMotor.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
+        backLeftMotor.setDirection(BACK_LEFT_MOTOR_DIRECTION);
+        frontRightMotor.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
+        backRightMotor.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+
+        frontLeftMotor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        backLeftMotor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        frontRightMotor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        backRightMotor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+    }
+
+    public void setFrontLeftMotorPower(double power) {
+        frontLeftMotor.setPower(power);
+    }
+
+    public void setBackLeftMotorPower(double power) {
+        backLeftMotor.setPower(power);
+    }
+
+    public void setFrontRightMotorPower(double power) {
+        frontRightMotor.setPower(power);
+    }
+
+    public void setBackRightMotorPower(double power) {
+        backRightMotor.setPower(power);
+    }
+
+    public void calculateTrajectory(Gamepad gamepad1) {
+        double max;
+
+        // POV Mode uses left joystick to go forward & strafe, and right joystick to rotate.
+        double axial = -gamepad1.left_stick_y;  // Note: pushing stick forward gives negative value
+        double lateral = gamepad1.left_stick_x;
+        double yaw = gamepad1.right_stick_x;
+
+        // Combine the joystick requests for each axis-motion to determine each wheel's power.
+        // Set up a variable for each drive wheel to save the power level for telemetry.
+        double leftFrontPower = axial + lateral + yaw;
+        double leftBackPower = axial - lateral + yaw;
+
+        double rightFrontPower = axial - lateral - yaw;
+        double rightBackPower = axial + lateral - yaw;
+
+        // Normalize the values so no wheel power exceeds 100%
+        // This ensures that the robot maintains the desired motion.
+        max = Math.max(Math.abs(leftFrontPower), Math.abs(rightFrontPower));
+        max = Math.max(max, Math.abs(leftBackPower));
+        max = Math.max(max, Math.abs(rightBackPower));
+
+        if (max > 1.0) {
+            leftFrontPower /= max;
+            rightFrontPower /= max;
+            leftBackPower /= max;
+            rightBackPower /= max;
+        }
+
+        // Send calculated power to wheels
+        this.setFrontLeftMotorPower(leftFrontPower * this.power);
+        this.setFrontRightMotorPower(rightFrontPower * this.power);
+        this.setBackLeftMotorPower(leftBackPower * this.power);
+        this.setBackRightMotorPower(rightBackPower * this.power);
+
+        // Show the elapsed game time and wheel power.
+        this.telemetry.addData("Front left/Right", "%4.2f, %4.2f", leftFrontPower, rightFrontPower);
+        this.telemetry.addData("Back  left/Right", "%4.2f, %4.2f", leftBackPower, rightBackPower);
+        this.telemetry.update();
+    }
+
+    public void setState(TravelState travelState) {
+        this.travelState = travelState;
+    }
+
+    public TravelState getState() {
+        return this.travelState;
+    }
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/subsystem/WristSubsystem.java

@@ -0,0 +1,79 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.wristBucket;
+import static org.firstinspires.ftc.teamcode.configs.RobotConstants.wristFloor;
+
+import com.qualcomm.robotcore.hardware.HardwareMap;
+import com.qualcomm.robotcore.hardware.ServoImplEx;
+
+import org.firstinspires.ftc.teamcode.util.action.Actions;
+import org.firstinspires.ftc.teamcode.util.action.RunAction;
+
+public class WristSubsystem {
+
+    public enum WristState {
+        FLOOR, BUCKET
+    }
+
+    public ServoImplEx wrist;
+    public WristState state;
+    public RunAction floorWrist, bucketWrist;
+
+    public WristSubsystem(HardwareMap hardwareMap, WristState wristState) {
+        wrist = hardwareMap.get(ServoImplEx.class, "wrist-servo");
+        wrist.resetDeviceConfigurationForOpMode();
+
+        this.state = wristState;
+
+        bucketWrist = new RunAction(this::bucketWrist);
+        floorWrist = new RunAction(this::floorWrist);
+    }
+
+    public void setState(WristState wristState) {
+        if (wristState == WristState.FLOOR) {
+            wrist.setPosition(wristFloor);
+            this.state = WristState.FLOOR;
+        } else if (wristState == WristState.BUCKET) {
+            wrist.setPosition(wristBucket);
+            this.state = WristState.BUCKET;
+        }
+    }
+
+    public void floorWrist() {
+        setState(WristState.FLOOR);
+    }
+
+    public void bucketWrist() {
+        setState(WristState.BUCKET);
+    }
+
+    public void switchState() {
+        if (state == WristState.FLOOR) {
+            setState(WristState.BUCKET);
+        } else if (state == WristState.BUCKET) {
+            setState(WristState.FLOOR);
+        }
+    }
+
+    public WristState getState() {
+        return this.state;
+    }
+
+    public void init() {
+        Actions.runBlocking(floorWrist);
+    }
+
+    public void start() {
+        Actions.runBlocking(floorWrist);
+    }
+
+    public double getPosition() {
+        return this.wrist.getPosition();
+    }
+
+    public void setPosition(double position) {
+        this.wrist.setPosition(position);
+    }
+
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/Action.java

@@ -0,0 +1,11 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.canvas.Canvas;
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+
+public interface Action {
+    boolean run(TelemetryPacket p);
+
+    default void preview(Canvas fieldOverlay) {
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/Actions.java

@@ -0,0 +1,24 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.canvas.Canvas;
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+
+public class Actions {
+
+    public static void runBlocking(Action a) {
+        FtcDashboard dash = FtcDashboard.getInstance();
+        Canvas c = new Canvas();
+        a.preview(c);
+
+        boolean b = true;
+        while (b && !Thread.currentThread().isInterrupted()) {
+            TelemetryPacket p = new TelemetryPacket();
+            p.fieldOverlay().getOperations().addAll(c.getOperations());
+
+            b = a.run(p);
+
+            dash.sendTelemetryPacket(p);
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/FieldConstants.java

@@ -0,0 +1,39 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.config.Config;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+
+@Config
+public class FieldConstants {
+
+    public enum RobotStart {
+        BLUE_BUCKET,
+        BLUE_OBSERVATION,
+        RED_BUCKET,
+        RED_OBSERVATION
+    }
+
+    public static final Pose blueBucketStartPose = new Pose(8, 79.5, Math.toRadians(180));
+    public static final Pose blueObservationStartPose = new Pose(8, 36, Math.toRadians(180));
+    public static final Pose redBucketStartPose = new Pose(144-8, 79.5, 0);
+    public static final Pose redObservationStartPose = new Pose(144-8, 36, 0);
+
+    // Blue Preload Poses
+    public static final Pose blueBucketPreloadPose = new Pose(34.5, 79.5, Math.toRadians(180));
+
+    // Blue Bucket Sample Poses
+    public static final Pose blueBucketLeftSamplePose = new Pose(34.75, 113.5, Math.toRadians(66));
+    public static final Pose blueBucketLeftSampleControlPose = new Pose(32, 108);
+    public static final Pose blueBucketMidSamplePose = new Pose(33, 125.5, Math.toRadians(73));
+    public static final Pose blueBucketMidSampleControlPose = new Pose(47.5, 110);
+    public static final Pose blueBucketRightSamplePose = new Pose(33, 133, Math.toRadians(74));
+    public static final Pose blueBucketRightSampleControlPose = new Pose(46, 101);
+
+    public static final Pose blueBucketScorePose = new Pose(16, 128, Math.toRadians(-45));
+
+    public static final Pose blueBucketParkPose = new Pose(65, 97.75, Math.toRadians(90));
+    public static final Pose blueBucketParkControlPose = new Pose(60.25, 123.5);
+
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/RunAction.java

@@ -0,0 +1,30 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+
+public class RunAction implements Action {
+
+    private final Runnable runnable;
+    private Runnable callback;
+
+    public RunAction(Runnable runnable) {
+        this.runnable = runnable;
+    }
+
+    public void runAction() {
+        runnable.run();
+        if (callback != null) {
+            callback.run();
+        }
+    }
+
+    public void setCallback(Runnable callback) {
+        this.callback = callback;
+    }
+
+    // Adapter to make Action compatible with the Action interface
+    public boolean run(TelemetryPacket p) {
+        runAction();
+        return false; // Regular actions complete after one execution
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/SequentialAction.java

@@ -0,0 +1,43 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.canvas.Canvas;
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SequentialAction implements Action {
+    private List<Action> actions;
+
+    public SequentialAction(List<Action> actions) {
+        this.actions = new ArrayList<>(actions);
+    }
+
+    public SequentialAction(Action... actions) {
+        this(Arrays.asList(actions));
+    }
+
+    @Override
+    public boolean run(TelemetryPacket p) {
+        if (actions.isEmpty()) {
+            return false;
+        }
+
+        if (actions.get(0).run(p)) {
+            return true;
+        } else {
+            actions.remove(0);
+            return run(p);
+        }
+    }
+
+    @Override
+    public void preview(Canvas fieldOverlay) {
+        for (Action a : actions) {
+            a.preview(fieldOverlay);
+        }
+    }
+
+
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/util/action/SleepAction.java

@@ -0,0 +1,32 @@
+package org.firstinspires.ftc.teamcode.util.action;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class SleepAction implements Action {
+    private final double dt;
+    private boolean isFinished = false;
+
+    public SleepAction(double dt) {
+        this.dt = dt;
+    }
+
+    @Override
+    public boolean run(TelemetryPacket p) {
+        if (!isFinished) {
+            Timer timer = new Timer();
+            timer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    isFinished = true;
+                }
+            }, (long) (dt * 1000));
+        } else {
+            isFinished = false; // Reset the flag after sleep is complete
+            return false; // Indicate that the action is finished
+        }
+        return true; // Indicate that the action is still running
+    }
+}