Ollie's work committed

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

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/CometBotDevAuto.java

@@ -0,0 +1,24 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+
+import org.firstinspires.ftc.teamcode.cometbots.CometBotAutoDevelopment;
+
+@TeleOp(name = "CometBot Auto", group = "Development")
+public class CometBotDevAuto extends OpMode {
+
+    public CometBotAutoDevelopment runMode;
+
+    @Override
+    public void init() {
+        this.runMode = new CometBotAutoDevelopment(hardwareMap, telemetry, gamepad1, gamepad2);
+        this.runMode.init();
+    }
+
+    @Override
+    public void loop() {
+        this.runMode.update();
+        telemetry.update();
+    }
+}

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

@@ -0,0 +1,64 @@
+package org.firstinspires.ftc.teamcode;
+import com.acmerobotics.roadrunner.Action;
+import com.acmerobotics.roadrunner.SleepAction;
+import com.acmerobotics.roadrunner.ftc.Actions;
+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.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.subsystem.AutoLine1;
+import org.firstinspires.ftc.teamcode.subsystem.AutoLine2;
+import org.firstinspires.ftc.teamcode.subsystem.AutoLine3;
+
+@Autonomous(name = "BlueNetAuto", group = "Dev")
+public class NetAuto extends OpMode {
+
+    public Follower follower;
+
+    public AutoLine1 myFirstPath = new AutoLine1();
+    public AutoLine2 mySecondPath = new AutoLine2();
+    public int pathState = 0;
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+        follower.setMaxPower(0.65);
+        myFirstPath.moveToAutoLine1(follower);
+    }
+
+    @Override
+    public void loop() {
+        follower.update();
+        switch(pathState) {
+            case 0:
+                if (!follower.isBusy()) {
+                    pathState = 1;
+                    mySecondPath.moveToAutoLine2(follower);
+                }
+            case 1:
+                if (!follower.isBusy()) {
+                    System.out.println("Finished");
+                }
+        }
+//        switch(pathState) {
+//            case 0:
+//                if (!follower.isBusy()) {
+//                    mySecondPath.moveToAutoLine2(follower);
+//                    pathState = 1;
+//                }
+//            case 1:
+//                if (!follower.isBusy()) {
+//                    pathState = 2;
+//                }
+//            case 2:
+//                // set path 3
+//                // as if busy, if not, set path 4 and so on.
+//                System.out.print("we're at the end");
+//
+//        }
+
+
+
+        follower.telemetryDebug(telemetry);
+    }
+}

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

@@ -10,14 +10,12 @@ public class PedroConstants {
     /*
         Robot parameters
     */
-    // Turn localizer - -0.003
-
 
     // Robot motor configurations
-    public static final String FRONT_LEFT_MOTOR = "Drive front lt";
+    public static final String FRONT_LEFT_MOTOR = "front-left";
-    public static final String BACK_LEFT_MOTOR  = "Drive back lt";
+    public static final String BACK_LEFT_MOTOR = "back-left";
-    public static final String FRONT_RIGHT_MOTOR  = "Drive front rt";
+    public static final String FRONT_RIGHT_MOTOR = "front-right";
-    public static final String BACK_RIGHT_MOTOR  = "Drive back rt";
+    public static final String BACK_RIGHT_MOTOR = "back-right";
 
     // Robot motor direction
     public static final Direction FRONT_LEFT_MOTOR_DIRECTION = Direction.REVERSE;
@@ -25,43 +23,55 @@ public class PedroConstants {
     public static final Direction FRONT_RIGHT_MOTOR_DIRECTION = Direction.FORWARD;
     public static final Direction BACK_RIGHT_MOTOR_DIRECTION = Direction.FORWARD;
 
+    /*
+        Motor Max Power
+    */
+    public static final double MAX_POWER = .75;
+
     // Robot IMU configuration
     public static final String IMU = "imu";
 
     // Robot IMU placement
     public static final RevHubOrientationOnRobot.LogoFacingDirection IMU_LOGO_FACING_DIRECTION
-            = RevHubOrientationOnRobot.LogoFacingDirection.DOWN;
+            = RevHubOrientationOnRobot.LogoFacingDirection.LEFT;
     public static final RevHubOrientationOnRobot.UsbFacingDirection IMU_USB_FACING_DIRECTION
-            = RevHubOrientationOnRobot.UsbFacingDirection.LEFT;
+            = RevHubOrientationOnRobot.UsbFacingDirection.UP;
 
     // Robot encoders
-    public static final String LEFT_ENCODER = "encoder left";
+    // NOTE:  Encoders are plugged into the same ports as motors hence the weird names
-    public static final String RIGHT_ENCODER = "encoder right";
+    public static final String RIGHT_ENCODER = "back-right"; //0
-    public static final String BACK_ENCODER = "encoder back";
+    public static final String BACK_ENCODER = "front-right"; //1
+    public static final String LEFT_ENCODER = "front-left"; //2
 
     // Robot encoder direction
     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;
 
+    // Arm config
+    public static final String SLIDE_MOTOR = "SlideMotor";
+    public static final String Claw_Servo = "ClawServo";
+    public static final String Wrist_Servo = "WristServo";
+    public static final String Arm_Servo = "ArmServo";
+
     /*
         Pedro's parameters
     */
 
     // The weight of the robot in Kilograms
-    public static final double ROBOT_WEIGHT_IN_KG = 10.5;
+    public static final double ROBOT_WEIGHT_IN_KG = 9;
 
     // Maximum velocity of the robot going forward
-    public static final double ROBOT_SPEED_FORWARD = 51.4598;
+    public static final double ROBOT_SPEED_FORWARD = 51.5;
 
     // Maximum velocity of the robot going right
-    public static final double ROBOT_SPEED_LATERAL = 28.7119;
+    public static final double ROBOT_SPEED_LATERAL = 28.7;
 
     // Rate of deceleration when power is cut-off when the robot is moving forward
-    public static final double FORWARD_ZERO_POWER_ACCEL = -57.805;
+    public static final double FORWARD_ZERO_POWER_ACCEL = -59.8;
 
     // Rate of deceleration when power is cut-off when the robot is moving to the right
-    public static final double LATERAL_ZERO_POWER_ACCEL = -99.672;
+    public static final double LATERAL_ZERO_POWER_ACCEL = -99.7;
 
     // 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 = 3.5;

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

@@ -0,0 +1,122 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+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;
+
+@Autonomous(name = "Pre Loaded Blue Basket Auto", group = "Competition")
+public class PreLoadedBlueBasketAuto extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(7.875, 89.357);
+
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        follower.setMaxPower(.45);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(8.036, 89.196, Point.CARTESIAN),
+                                new Point(10.125, 126.804, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(10.125, 126.804, Point.CARTESIAN),
+                                new Point(37.607, 90.000, Point.CARTESIAN),
+                                new Point(62.357, 119.893, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 3
+                        new BezierCurve(
+                                new Point(62.357, 119.893, Point.CARTESIAN),
+                                new Point(33.750, 112.500, Point.CARTESIAN),
+                                new Point(15.107, 130.661, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 4
+                        new BezierCurve(
+                                new Point(15.107, 130.661, Point.CARTESIAN),
+                                new Point(58.821, 103.018, Point.CARTESIAN),
+                                new Point(59.625, 126.964, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(59.625, 126.964, Point.CARTESIAN),
+                                new Point(15.107, 130.339, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(15.107, 130.339, Point.CARTESIAN),
+                                new Point(59.625, 126.964, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(59.625, 126.964, Point.CARTESIAN),
+                                new Point(57.857, 133.071, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(57.857, 133.071, Point.CARTESIAN),
+                                new Point(18.964, 134.679, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 9
+                        new BezierCurve(
+                                new Point(18.964, 134.679, Point.CARTESIAN),
+                                new Point(84.536, 131.786, Point.CARTESIAN),
+                                new Point(80.036, 96.429, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(270)).build();
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    @Override
+    public void loop() {
+        follower.update();
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

@@ -0,0 +1,151 @@
+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 = "BlueNonBasketAuto", group = "Autonomous Pathing Tuning")
+public class BlueNonBasketAuto extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(10.929, 55.446, 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(.45);
+
+        follower.setStartingPose(startPose);
+
+        path = follower.pathBuilder()
+                .addPath(
+                // Line 1
+                new BezierCurve(
+                        new Point(10.929, 55.446, Point.CARTESIAN),
+                        new Point(42.429, 46.446, Point.CARTESIAN),
+                        new Point(36.321, 38.089, Point.CARTESIAN)
+                )
+        )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(36.321, 38.089, Point.CARTESIAN),
+                                new Point(59.786, 36.643, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(59.786, 36.643, Point.CARTESIAN),
+                                new Point(59.304, 24.750, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(59.304, 24.750, Point.CARTESIAN),
+                                new Point(13.982, 23.946, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(13.982, 23.946, Point.CARTESIAN),
+                                new Point(59.464, 24.429, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(59.464, 24.429, Point.CARTESIAN),
+                                new Point(58.982, 15.268, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(58.982, 15.268, Point.CARTESIAN),
+                                new Point(13.821, 14.464, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(13.821, 14.464, Point.CARTESIAN),
+                                new Point(58.661, 13.500, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(58.661, 13.500, Point.CARTESIAN),
+                                new Point(58.339, 8.679, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(58.339, 8.679, Point.CARTESIAN),
+                                new Point(14.625, 8.518, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0)).build();
+        follower.followPath(path, true);
+
+        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, true);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

@@ -0,0 +1,142 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.MAX_POWER;
+
+import androidx.annotation.NonNull;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+import com.acmerobotics.roadrunner.Action;
+import com.acmerobotics.roadrunner.SequentialAction;
+import com.acmerobotics.roadrunner.SleepAction;
+import com.acmerobotics.roadrunner.ftc.Actions;
+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.states.FieldStates;
+import org.firstinspires.ftc.teamcode.subsystem.MotorsSubsystem;
+
+public class CometBotAutoDevelopment {
+
+    /*
+    Subsystems
+     */
+    private MotorsSubsystem motors;
+
+    /*
+    Controllers
+     */
+    public Gamepad GP1;
+    public Gamepad GP2;
+    public Gamepad currentGP1;
+    public Gamepad previousGP1;
+    public Gamepad currentGP2;
+    public Gamepad previousGP2;
+    private Telemetry telemetry;
+
+    public FieldStates fieldStates;
+    private boolean centricity = false;
+
+    private Follower follower;
+    private HardwareMap hardwareMap;
+
+    public CometBotAutoDevelopment(HardwareMap hardwareMap, Telemetry telemetry, Gamepad gp1, Gamepad gp2) {
+        this.motors = new MotorsSubsystem(hardwareMap, telemetry);
+        this.GP1 = gp1;
+        this.GP2 = gp2;
+        this.hardwareMap = hardwareMap;
+        this.telemetry = telemetry;
+        this.currentGP1 = new Gamepad();
+        this.currentGP2 = new Gamepad();
+        this.previousGP1 = new Gamepad();
+        this.previousGP2 = new Gamepad();
+        this.fieldStates = new FieldStates();
+        this.follower = new Follower(hardwareMap);
+    }
+
+    public class ZeroOutPower implements Action {
+
+        @Override
+        public boolean run(@NonNull TelemetryPacket telemetryPacket) {
+            follower = new Follower(hardwareMap);
+            follower.setMaxPower(0);
+            System.out.println("Running ZeroOutPower");
+            return follower.isBusy();
+        }
+    }
+
+    public class ReturnToMaxPower implements Action {
+
+        @Override
+        public boolean run(@NonNull TelemetryPacket telemetryPacket) {
+            follower = new Follower(hardwareMap);
+            follower.setMaxPower(MAX_POWER);
+            follower.startTeleopDrive();
+            System.out.println("Running ReturnToMaxPower");
+            return follower.isBusy();
+        }
+    }
+
+    public Action zeroOutPower() {
+        return new ZeroOutPower();
+    }
+
+    public Action returnToMaxPower() {
+        return new ReturnToMaxPower();
+    }
+
+    public void init() {
+        this.motors.init();
+        this.fieldStates.setFieldLocation(FieldStates.FieldLocation.TRAVELING);
+        follower.setMaxPower(MAX_POWER);
+        follower.startTeleopDrive();
+    }
+
+    public void update() {
+        this.previousGP1.copy(currentGP1);
+        this.currentGP1.copy(this.GP1);
+        this.previousGP2.copy(currentGP2);
+        this.currentGP2.copy(this.GP2);
+
+        this.toFixMotorBlockingIssueFirstMethod();
+        this.toFixMotorBlockingIssueSecondMethod();
+        this.changeCentricity();
+
+        follower.setTeleOpMovementVectors(-this.GP1.left_stick_y, -this.GP1.left_stick_x, -this.GP1.right_stick_x, centricity);
+        follower.update();
+        this.telemetry.addData("Field State", this.fieldStates.getFieldLocation());
+    }
+
+    public void changeCentricity() {
+        if (this.currentGP1.left_bumper && !this.previousGP1.left_bumper) {
+            this.centricity = !centricity;
+            this.follower.breakFollowing();
+            this.follower.startTeleopDrive();
+        }
+    }
+
+    public void toFixMotorBlockingIssueFirstMethod() {
+        if (this.currentGP1.cross && !this.previousGP1.cross) {
+            fieldStates.setFieldLocation(FieldStates.FieldLocation.BUCKET);
+            Actions.runBlocking(new SequentialAction(
+                    this.zeroOutPower(),
+                    new SleepAction(3),
+                    this.returnToMaxPower()
+            ));
+            fieldStates.setFieldLocation(FieldStates.FieldLocation.TRAVELING);
+        }
+    }
+
+    public void toFixMotorBlockingIssueSecondMethod() {
+        if (this.currentGP1.circle && !this.previousGP1.circle) {
+            this.follower.breakFollowing();
+            fieldStates.setFieldLocation(FieldStates.FieldLocation.BUCKET);
+            Actions.runBlocking(new SequentialAction(
+                    new SleepAction(3)
+            ));
+            fieldStates.setFieldLocation(FieldStates.FieldLocation.TRAVELING);
+            this.follower.startTeleopDrive();
+        }
+    }
+}

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

@@ -0,0 +1,135 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+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/projects/AutoExample.java

@@ -0,0 +1,79 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+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/projects/AutoExampleFour.java

@@ -1,17 +1,10 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
-
-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;
 
 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")
+@Autonomous(name = "AutoExample - 2 Curves/2 Lines", group = "Autonomous Pathing Tuning")
-public class AutoExample extends OpMode {
+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 BezierCurve(
-                                new Point(12.804, 11.223, Point.CARTESIAN),
+                                new Point(12.000, 60.000, Point.CARTESIAN),
-                                new Point(12.804, 42.362, 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 BezierLine(
-                                new Point(12.804, 42.362, Point.CARTESIAN),
+                                new Point(60.000, 12.000, Point.CARTESIAN),
-                                new Point(11.381, 57.379, Point.CARTESIAN),
+                                new Point(40.000, 12.000, Point.CARTESIAN)
-                                new Point(31.614, 56.588, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
                 .addPath(
                         // Line 3
-                        new BezierLine(
+                        new BezierCurve(
-                                new Point(31.614, 56.588, Point.CARTESIAN),
+                                new Point(40.000, 12.000, Point.CARTESIAN),
-                                new Point(51.214, 56.746, 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 BezierLine(
-                                new Point(51.214, 56.746, Point.CARTESIAN),
+                                new Point(12.000, 35.000, Point.CARTESIAN),
-                                new Point(64.334, 58.643, Point.CARTESIAN),
+                                new Point(12.000, 60.000, Point.CARTESIAN)
-                                new Point(61.172, 45.524, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(0))
-                .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()
                 .build();
 
         follower.followPath(path);

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

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

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

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
 
 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(7.467869222096955, 59.74295377677565);
+    private final Pose startPose = new Pose(10,45, 0);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -52,21 +52,21 @@ public class AutoExampleThree extends OpMode {
                 .addPath(
                         // Line 1
                         new BezierCurve(
-                                new Point(7.468, 59.743, Point.CARTESIAN),
+                                new Point(10.000, 45.000, Point.CARTESIAN),
-                                new Point(67.860, 12.014, Point.CARTESIAN),
+                                new Point(45.000, 45.000, Point.CARTESIAN),
-                                new Point(101.790, 36.041, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN)
-                                new Point(68.347, 22.891, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation()
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
                 .addPath(
                         // Line 2
                         new BezierLine(
-                                new Point(68.347, 22.891, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN),
-                                new Point(13.637, 24.352, Point.CARTESIAN)
+                                new Point(10.000, 20.000, Point.CARTESIAN)
                         )
                 )
-                .setTangentHeadingInterpolation().build();
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
+                .build();
 
         follower.followPath(path);
 

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

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
 
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;
@@ -10,7 +10,6 @@ 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;
 
@@ -26,7 +25,7 @@ import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
  * @version 1.0, 3/12/2024
  */
 @Config
-@Autonomous(name = "AutoExampleTwo", group = "Autonomous Pathing Tuning")
+@Autonomous(name = "AutoExample - Simple Curve", group = "Autonomous Pathing Tuning")
 public class AutoExampleTwo extends OpMode {
     private Telemetry telemetryA;
 
@@ -34,7 +33,7 @@ public class AutoExampleTwo extends OpMode {
 
     private PathChain path;
 
-    private final Pose startPose = new Pose(10.0, 40, 90);
+    private final Pose startPose = new Pose(10.0, 45, 0);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -51,28 +50,14 @@ public class AutoExampleTwo extends OpMode {
         path = follower.pathBuilder()
                 .addPath(
                         // Line 1
-                        new BezierLine(
+                        new BezierCurve(
-                                new Point(10.000, 40.000, Point.CARTESIAN),
+                                new Point(10.000, 45.000, Point.CARTESIAN),
-                                new Point(60.000, 40.000, Point.CARTESIAN)
+                                new Point(45.000, 45.000, Point.CARTESIAN),
+                                new Point(50.000, 20.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
-                .addPath(
+                .build();
-                        // 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)
-                        )
-                )
-                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
 
         follower.followPath(path);
 

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/AutoTest.java

@@ -0,0 +1,91 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+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.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 = "Test", group = "Autonomous Pathing Tuning")
+public class AutoTest extends OpMode {
+    private Telemetry telemetryA;
+
+
+    private Follower follower;
+
+    private PathChain test;
+
+    @Override
+    public void init() {
+        follower = new Follower(hardwareMap);
+
+        test = follower.pathBuilder()
+                .addPath(
+        new BezierLine(
+                new Point(8.000, 60.000, Point.CARTESIAN),
+                new Point(18.000, 60.000, Point.CARTESIAN)
+        )
+      )
+
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(18.000, 60.000, Point.CARTESIAN),
+                                new Point(18.000, 23.000, Point.CARTESIAN),
+                                new Point(48.000, 23.000, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(48.000, 23.000, Point.CARTESIAN),
+                                new Point(60.000, 36.000, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(60.000, 36.000, Point.CARTESIAN),
+                                new Point(60.000, 49.000, Point.CARTESIAN)
+                        )
+                ).build();
+
+
+        follower.followPath(test);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(test);
+        }
+
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

@@ -27,7 +27,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
 
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
@@ -44,7 +44,6 @@ import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTI
 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.Disabled;
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
 import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
 import com.qualcomm.robotcore.hardware.DcMotor;

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/BlueAuto.java

@@ -0,0 +1,128 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+public class BlueAuto {
+
+
+
+    public void GeneratedPath() {
+        PathBuilder builder = new PathBuilder();
+
+        builder
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(9.757, 84.983, Point.CARTESIAN),
+                                new Point(8.442, 129.227, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(8.442, 129.227, Point.CARTESIAN),
+                                new Point(52.762, 101.628, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(52.762, 101.628, Point.CARTESIAN),
+                                new Point(79.224, 116.564, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(79.224, 116.564, Point.CARTESIAN),
+                                new Point(54.548, 130.525, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(54.548, 130.525, Point.CARTESIAN),
+                                new Point(12.338, 133.772, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(12.338, 133.772, Point.CARTESIAN),
+                                new Point(52.437, 101.628, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(52.437, 101.628, Point.CARTESIAN),
+                                new Point(71.594, 120.947, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(71.594, 120.947, Point.CARTESIAN),
+                                new Point(52.275, 120.785, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(52.275, 120.785, Point.CARTESIAN),
+                                new Point(11.039, 131.012, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(11.039, 131.012, Point.CARTESIAN),
+                                new Point(70.782, 120.460, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 11
+                        new BezierLine(
+                                new Point(70.782, 120.460, Point.CARTESIAN),
+                                new Point(50.327, 142.377, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 12
+                        new BezierLine(
+                                new Point(50.327, 142.377, Point.CARTESIAN),
+                                new Point(13.799, 134.422, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 13
+                        new BezierLine(
+                                new Point(13.799, 134.422, Point.CARTESIAN),
+                                new Point(13.799, 134.422, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 14
+                        new BezierLine(
+                                new Point(13.799, 134.422, Point.CARTESIAN),
+                                new Point(71.919, 103.901, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation();
+    }
+}

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

@@ -0,0 +1,161 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+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, 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(.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, true);
+
+        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, true);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
 
 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/projects/BluenbAutov1.java

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

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/GeneratedPath.java

@@ -0,0 +1,109 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+public class GeneratedPath {
+    public GeneratedPath() {
+        PathBuilder builder = new PathBuilder();
+
+        builder
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(9.757, 84.983, Point.CARTESIAN),
+                                new Point(28.573, 76.302, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(28.573, 76.302, Point.CARTESIAN),
+                                new Point(36.203, 76.140, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(36.203, 76.140, Point.CARTESIAN),
+                                new Point(35.067, 35.716, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(35.067, 35.716, Point.CARTESIAN),
+                                new Point(73.705, 34.742, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(73.705, 34.742, Point.CARTESIAN),
+                                new Point(73.705, 24.839, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(73.705, 24.839, Point.CARTESIAN),
+                                new Point(7.630, 26.462, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(7.630, 26.462, Point.CARTESIAN),
+                                new Point(64.126, 22.728, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(64.126, 22.728, Point.CARTESIAN),
+                                new Point(63.964, 13.150, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(63.964, 13.150, Point.CARTESIAN),
+                                new Point(12.338, 15.260, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(12.338, 15.260, Point.CARTESIAN),
+                                new Point(63.802, 13.150, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 11
+                        new BezierLine(
+                                new Point(63.802, 13.150, Point.CARTESIAN),
+                                new Point(63.639, 11.689, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 12
+                        new BezierLine(
+                                new Point(63.639, 11.689, Point.CARTESIAN),
+                                new Point(12.014, 11.689, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation();
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/RedAuto.java

@@ -0,0 +1,99 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+
+
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+public class RedAuto {
+
+
+    public class GeneratedPath {
+
+        public GeneratedPath() {
+            PathBuilder builder = new PathBuilder();
+
+            builder
+                    .addPath(
+                            // Line 1
+                            new BezierLine(
+                                    new Point(131.499, 58.931, Point.CARTESIAN),
+                                    new Point(131.986, 18.183, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 2
+                            new BezierLine(
+                                    new Point(131.986, 18.183, Point.CARTESIAN),
+                                    new Point(90.264, 40.911, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 3
+                            new BezierLine(
+                                    new Point(90.264, 40.911, Point.CARTESIAN),
+                                    new Point(83.445, 26.300, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 4
+                            new BezierLine(
+                                    new Point(83.445, 26.300, Point.CARTESIAN),
+                                    new Point(136.207, 14.286, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 5
+                            new BezierLine(
+                                    new Point(136.207, 14.286, Point.CARTESIAN),
+                                    new Point(81.497, 24.352, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 6
+                            new BezierLine(
+                                    new Point(81.497, 24.352, Point.CARTESIAN),
+                                    new Point(82.634, 12.988, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 7
+                            new BezierLine(
+                                    new Point(82.634, 12.988, Point.CARTESIAN),
+                                    new Point(133.935, 11.364, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 8
+                            new BezierLine(
+                                    new Point(133.935, 11.364, Point.CARTESIAN),
+                                    new Point(82.309, 11.689, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 9
+                            new BezierLine(
+                                    new Point(82.309, 11.689, Point.CARTESIAN),
+                                    new Point(83.445, 2.598, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation()
+                    .addPath(
+                            // Line 10
+                            new BezierLine(
+                                    new Point(83.445, 2.598, Point.CARTESIAN),
+                                    new Point(132.149, 10.390, Point.CARTESIAN)
+                            )
+                    )
+                    .setTangentHeadingInterpolation();
+        }
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/SensorBNO055IMU.java

@@ -0,0 +1,185 @@
+/* Copyright (c) 2017 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.projects;
+
+import com.qualcomm.hardware.bosch.BNO055IMU;
+import com.qualcomm.hardware.bosch.JustLoggingAccelerationIntegrator;
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+
+import org.firstinspires.ftc.robotcore.external.Func;
+import org.firstinspires.ftc.robotcore.external.navigation.Acceleration;
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder;
+import org.firstinspires.ftc.robotcore.external.navigation.AxesReference;
+import org.firstinspires.ftc.robotcore.external.navigation.Orientation;
+import org.firstinspires.ftc.robotcore.external.navigation.Position;
+import org.firstinspires.ftc.robotcore.external.navigation.Velocity;
+
+import java.util.Locale;
+
+/*
+ * This OpMode gives a short demo on how to use the BNO055 Inertial Motion Unit (IMU) from AdaFruit.
+ *
+ * Note: this is a Legacy example that will not work with newer Control/Expansion Hubs that use a different IMU
+ * Please use the new SensorIMUOrthogonal or SensorIMUNonOrthogonal samples for a more universal IMU interface.
+ *
+ * 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
+ *
+ * @see <a href="http://www.adafruit.com/products/2472">Adafruit IMU</a>
+ */
+@TeleOp(name = "Sensor: BNO055 IMU", group = "Sensor")
+public class SensorBNO055IMU extends LinearOpMode
+    {
+    //----------------------------------------------------------------------------------------------
+    // State
+    //----------------------------------------------------------------------------------------------
+
+    // The IMU sensor object
+    BNO055IMU imu;
+
+    // State used for updating telemetry
+    Orientation angles;
+    Acceleration gravity;
+
+    //----------------------------------------------------------------------------------------------
+    // Main logic
+    //----------------------------------------------------------------------------------------------
+
+    @Override public void runOpMode() {
+
+        // Set up the parameters with which we will use our IMU. Note that integration
+        // algorithm here just reports accelerations to the logcat log; it doesn't actually
+        // provide positional information.
+        BNO055IMU.Parameters parameters = new BNO055IMU.Parameters();
+        parameters.angleUnit           = BNO055IMU.AngleUnit.DEGREES;
+        parameters.accelUnit           = BNO055IMU.AccelUnit.METERS_PERSEC_PERSEC;
+        parameters.calibrationDataFile = "BNO055IMUCalibration.json"; // see the calibration sample OpMode
+        parameters.loggingEnabled      = true;
+        parameters.loggingTag          = "IMU";
+        parameters.accelerationIntegrationAlgorithm = new JustLoggingAccelerationIntegrator();
+
+        // Retrieve and initialize the IMU. We expect the IMU to be attached to an I2C port
+        // on a Core Device Interface Module, configured to be a sensor of type "AdaFruit IMU",
+        // and named "imu".
+        imu = hardwareMap.get(BNO055IMU.class, "adafruit_imu");
+        imu.initialize(parameters);
+
+        // Set up our telemetry dashboard
+        composeTelemetry();
+
+        // Wait until we're told to go
+        waitForStart();
+
+        // Start the logging of measured acceleration
+        imu.startAccelerationIntegration(new Position(), new Velocity(), 1000);
+
+        // Loop and update the dashboard
+        while (opModeIsActive()) {
+            telemetry.update();
+        }
+    }
+
+    //----------------------------------------------------------------------------------------------
+    // Telemetry Configuration
+    //----------------------------------------------------------------------------------------------
+
+    void composeTelemetry() {
+
+        // At the beginning of each telemetry update, grab a bunch of data
+        // from the IMU that we will then display in separate lines.
+        telemetry.addAction(new Runnable() { @Override public void run()
+                {
+                // Acquiring the angles is relatively expensive; we don't want
+                // to do that in each of the three items that need that info, as that's
+                // three times the necessary expense.
+                angles   = imu.getAngularOrientation(AxesReference.INTRINSIC, AxesOrder.ZYX, AngleUnit.DEGREES);
+                gravity  = imu.getGravity();
+                }
+            });
+
+        telemetry.addLine()
+            .addData("status", new Func<String>() {
+                @Override public String value() {
+                    return imu.getSystemStatus().toShortString();
+                    }
+                })
+            .addData("calib", new Func<String>() {
+                @Override public String value() {
+                    return imu.getCalibrationStatus().toString();
+                    }
+                });
+
+        telemetry.addLine()
+            .addData("heading", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.firstAngle);
+                    }
+                })
+            .addData("roll", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.secondAngle);
+                    }
+                })
+            .addData("pitch", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.thirdAngle);
+                    }
+                });
+
+        telemetry.addLine()
+            .addData("grvty", new Func<String>() {
+                @Override public String value() {
+                    return gravity.toString();
+                    }
+                })
+            .addData("mag", new Func<String>() {
+                @Override public String value() {
+                    return String.format(Locale.getDefault(), "%.3f",
+                            Math.sqrt(gravity.xAccel*gravity.xAccel
+                                    + gravity.yAccel*gravity.yAccel
+                                    + gravity.zAccel*gravity.zAccel));
+                    }
+                });
+    }
+
+    //----------------------------------------------------------------------------------------------
+    // Formatting
+    //----------------------------------------------------------------------------------------------
+
+    String formatAngle(AngleUnit angleUnit, double angle) {
+        return formatDegrees(AngleUnit.DEGREES.fromUnit(angleUnit, angle));
+    }
+
+    String formatDegrees(double degrees){
+        return String.format(Locale.getDefault(), "%.1f", AngleUnit.DEGREES.normalize(degrees));
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/SensorBNO055IMUCalibration.java

@@ -0,0 +1,229 @@
+/* Copyright (c) 2017 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.projects;
+
+import com.qualcomm.hardware.bosch.BNO055IMU;
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.util.ReadWriteFile;
+
+import org.firstinspires.ftc.robotcore.external.Func;
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder;
+import org.firstinspires.ftc.robotcore.external.navigation.AxesReference;
+import org.firstinspires.ftc.robotcore.external.navigation.Orientation;
+import org.firstinspires.ftc.robotcore.internal.system.AppUtil;
+
+import java.io.File;
+import java.util.Locale;
+
+/*
+ * This OpMode calibrates a BNO055 IMU per
+ * "Section 3.11 Calibration" of the BNO055 specification.
+ *
+ *  Note: this is a Legacy example that will not work with newer Control/Expansion Hubs that use a different IMU
+ *  Please use the new SensorIMUOrthogonal or SensorIMUNonOrthogonal samples for a more universal IMU interface.
+ *
+ * Manual calibration of the IMU is definitely NOT necessary: except for the magnetometer (which is not used by the
+ * default "IMU" SensorMode), the BNO055 is internally self-calibrating and thus can be very successfully used without
+ * manual intervention. That said, performing a one-time calibration, saving the results persistently, then loading them
+ * again at each run can help reduce the time that automatic calibration requires.
+ *
+ * This summary of the calibration process from Intel is informative:
+ * http://iotdk.intel.com/docs/master/upm/classupm_1_1_b_n_o055.html
+ *
+ * "This device requires calibration in order to operate accurately. [...] Calibration data is
+ * lost on a power cycle. See one of the examples for a description of how to calibrate the device,
+ * but in essence:
+ *
+ * There is a calibration status register available [...] that returns the calibration status
+ * of the accelerometer (ACC), magnetometer (MAG), gyroscope (GYR), and overall system (SYS).
+ * Each of these values range from 0 (uncalibrated) to 3 (fully calibrated). Calibration [ideally]
+ * involves certain motions to get all 4 values at 3. The motions are as follows (though see the
+ * datasheet for more information):
+ *
+ *     1. GYR: Simply let the sensor sit flat for a few seconds.</ol>
+ *     2. ACC: Move the sensor in various positions. Start flat, then rotate slowly by 45
+ *             degrees, hold for a few seconds, then continue rotating another 45 degrees and
+ *             hold, etc. 6 or more movements of this type may be required. You can move through
+ *             any axis you desire, but make sure that the device is lying at least once
+ *             perpendicular to the x, y, and z axis.</ol>
+ *     3. MAG: Move slowly in a figure 8 pattern in the air, until the calibration values reaches 3.</ol>
+ *     4. SYS: This will usually reach 3 when the other items have also reached 3. If not, continue
+ *             slowly moving the device though various axes until it does."</ol>
+ *
+ * To calibrate the IMU, run this sample OpMode with a gamepad attached to the driver station.
+ * Once the IMU has reached sufficient calibration as reported on telemetry, press the 'A'
+ * button on the gamepad to write the calibration to a file. That file can then be indicated
+ * later when running an OpMode which uses the IMU.
+ *
+ * Note: if your intended uses of the IMU do not include use of all its sensors (for example,
+ * you might not use the magnetometer), then it makes little sense for you to wait for full
+ * calibration of the sensors you are not using before saving the calibration data. Indeed,
+ * it appears that in a SensorMode that doesn't use the magnetometer (for example), the
+ * magnetometer cannot actually be calibrated.
+ *
+ * References:
+ * The AdafruitBNO055IMU Javadoc
+ * The BNO055IMU.Parameters.calibrationDataFile Javadoc
+ * The BNO055 product page: https://www.bosch-sensortec.com/bst/products/all_products/bno055
+ * The BNO055 datasheet: https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bno055-ds000.pdf
+ */
+@TeleOp(name = "Sensor: BNO055 IMU Calibration", group = "Sensor")
+public class SensorBNO055IMUCalibration extends LinearOpMode
+    {
+    //----------------------------------------------------------------------------------------------
+    // State
+    //----------------------------------------------------------------------------------------------
+
+    // Our sensors, motors, and other devices go here, along with other long term state
+    BNO055IMU imu;
+
+    // State used for updating telemetry
+    Orientation angles;
+
+    //----------------------------------------------------------------------------------------------
+    // Main logic
+    //----------------------------------------------------------------------------------------------
+
+    @Override public void runOpMode() {
+
+        telemetry.log().setCapacity(12);
+        telemetry.log().add("");
+        telemetry.log().add("Please refer to the calibration instructions");
+        telemetry.log().add("contained in the Adafruit IMU calibration");
+        telemetry.log().add("sample OpMode.");
+        telemetry.log().add("");
+        telemetry.log().add("When sufficient calibration has been reached,");
+        telemetry.log().add("press the 'A' button to write the current");
+        telemetry.log().add("calibration data to a file.");
+        telemetry.log().add("");
+
+        // We are expecting the IMU to be attached to an I2C port on a Core Device Interface Module and named "imu".
+        BNO055IMU.Parameters parameters = new BNO055IMU.Parameters();
+        parameters.loggingEnabled = true;
+        parameters.loggingTag     = "IMU";
+        imu = hardwareMap.get(BNO055IMU.class, "adafruit_imu");
+        imu.initialize(parameters);
+
+        composeTelemetry();
+        telemetry.log().add("Waiting for start...");
+
+        // Wait until we're told to go
+        while (!isStarted()) {
+            telemetry.update();
+            idle();
+        }
+
+        telemetry.log().add("...started...");
+
+        while (opModeIsActive()) {
+
+            if (gamepad1.a) {
+
+                // Get the calibration data
+                BNO055IMU.CalibrationData calibrationData = imu.readCalibrationData();
+
+                // Save the calibration data to a file. You can choose whatever file
+                // name you wish here, but you'll want to indicate the same file name
+                // when you initialize the IMU in an OpMode in which it is used. If you
+                // have more than one IMU on your robot, you'll of course want to use
+                // different configuration file names for each.
+                String filename = "AdafruitIMUCalibration.json";
+                File file = AppUtil.getInstance().getSettingsFile(filename);
+                ReadWriteFile.writeFile(file, calibrationData.serialize());
+                telemetry.log().add("saved to '%s'", filename);
+
+                // Wait for the button to be released
+                while (gamepad1.a) {
+                    telemetry.update();
+                    idle();
+                }
+            }
+
+            telemetry.update();
+        }
+    }
+
+    void composeTelemetry() {
+
+        // At the beginning of each telemetry update, grab a bunch of data
+        // from the IMU that we will then display in separate lines.
+        telemetry.addAction(new Runnable() { @Override public void run()
+                {
+                // Acquiring the angles is relatively expensive; we don't want
+                // to do that in each of the three items that need that info, as that's
+                // three times the necessary expense.
+                angles   = imu.getAngularOrientation(AxesReference.INTRINSIC, AxesOrder.ZYX, AngleUnit.DEGREES);
+                }
+            });
+
+        telemetry.addLine()
+            .addData("status", new Func<String>() {
+                @Override public String value() {
+                    return imu.getSystemStatus().toShortString();
+                    }
+                })
+            .addData("calib", new Func<String>() {
+                @Override public String value() {
+                    return imu.getCalibrationStatus().toString();
+                    }
+                });
+
+        telemetry.addLine()
+            .addData("heading", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.firstAngle);
+                    }
+                })
+            .addData("roll", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.secondAngle);
+                    }
+                })
+            .addData("pitch", new Func<String>() {
+                @Override public String value() {
+                    return formatAngle(angles.angleUnit, angles.thirdAngle);
+                    }
+                });
+    }
+
+    //----------------------------------------------------------------------------------------------
+    // Formatting
+    //----------------------------------------------------------------------------------------------
+
+    String formatAngle(AngleUnit angleUnit, double angle) {
+        return formatDegrees(AngleUnit.DEGREES.fromUnit(angleUnit, angle));
+    }
+
+    String formatDegrees(double degrees){
+        return String.format(Locale.getDefault(), "%.1f", AngleUnit.DEGREES.normalize(degrees));
+    }
+}

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

@@ -27,7 +27,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-package org.firstinspires.ftc.teamcode;
+package org.firstinspires.ftc.teamcode.cometbots.projects;
 
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
 import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
@@ -48,6 +48,7 @@ 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;
 
 /*

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/bBlueAutoV1.java

@@ -0,0 +1,237 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+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.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+@Autonomous(name = "org.firstinspires.ftc.teamcode.cometbots.projects.bBlueAutoV1", group = "V1")
+public class bBlueAutoV1 extends OpMode {
+
+    public Telemetry telemetry;
+    public Follower robot;
+    public PathChain path;
+
+    @Override
+    public void init() {
+        robot = new Follower(hardwareMap);
+
+        PathBuilder builder = new PathBuilder();
+
+       path = builder
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(9.757, 84.983, Point.CARTESIAN),
+                                new Point(28.573, 76.302, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(28.573, 76.302, Point.CARTESIAN),
+                                new Point(36.203, 76.140, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(36.203, 76.140, Point.CARTESIAN),
+                                new Point(35.067, 35.716, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(35.067, 35.716, Point.CARTESIAN),
+                                new Point(73.705, 34.742, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(73.705, 34.742, Point.CARTESIAN),
+                                new Point(73.705, 24.839, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(73.705, 24.839, Point.CARTESIAN),
+                                new Point(7.630, 26.462, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(7.630, 26.462, Point.CARTESIAN),
+                                new Point(64.126, 22.728, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(64.126, 22.728, Point.CARTESIAN),
+                                new Point(63.964, 13.150, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(63.964, 13.150, Point.CARTESIAN),
+                                new Point(12.338, 15.260, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(12.338, 15.260, Point.CARTESIAN),
+                                new Point(63.802, 13.150, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 11
+                        new BezierLine(
+                                new Point(63.802, 13.150, Point.CARTESIAN),
+                                new Point(63.639, 11.689, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 12
+                        new BezierLine(
+                                new Point(63.639, 11.689, Point.CARTESIAN),
+                                new Point(12.014, 11.689, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 13
+                        new BezierLine(
+                                new Point(12.014, 11.689, Point.CARTESIAN),
+                                new Point(62.665, 30.196, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 14
+                        new BezierLine(
+                                new Point(62.665, 30.196, Point.CARTESIAN),
+                                new Point(13.312, 51.463, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 15
+                        new BezierLine(
+                                new Point(13.312, 51.463, Point.CARTESIAN),
+                                new Point(16.234, 103.738, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 16
+                        new BezierLine(
+                                new Point(16.234, 103.738, Point.CARTESIAN),
+                                new Point(68.023, 108.284, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 17
+                        new BezierLine(
+                                new Point(68.023, 108.284, Point.CARTESIAN),
+                                new Point(68.185, 121.109, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 18
+                        new BezierLine(
+                                new Point(68.185, 121.109, Point.CARTESIAN),
+                                new Point(21.754, 119.811, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 19
+                        new BezierLine(
+                                new Point(21.754, 119.811, Point.CARTESIAN),
+                                new Point(11.526, 129.227, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 20
+                        new BezierLine(
+                                new Point(11.526, 129.227, Point.CARTESIAN),
+                                new Point(72.568, 111.856, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 21
+                        new BezierLine(
+                                new Point(72.568, 111.856, Point.CARTESIAN),
+                                new Point(58.607, 128.902, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 22
+                        new BezierLine(
+                                new Point(58.607, 128.902, Point.CARTESIAN),
+                                new Point(11.364, 130.850, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 23
+                        new BezierLine(
+                                new Point(11.364, 130.850, Point.CARTESIAN),
+                                new Point(58.931, 128.577, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 24
+                        new BezierLine(
+                                new Point(58.931, 128.577, Point.CARTESIAN),
+                                new Point(58.769, 133.123, Point.CARTESIAN)
+                        )
+                )
+
+                .addPath(
+                        // Line 25
+                        new BezierLine(
+                                new Point(58.769, 133.123, Point.CARTESIAN),
+                                new Point(13.475, 133.935, Point.CARTESIAN)
+                        )
+                ).build();
+        ;
+    }
+
+
+    @Override
+    public void loop() {
+        robot.update();
+        if (robot.atParametricEnd())
+            robot.followPath(path);
+        robot.telemetryDebug(telemetry);
+    }
+}

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/projects/bRedAutoV1.java

@@ -0,0 +1,174 @@
+package org.firstinspires.ftc.teamcode.cometbots.projects;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+public class bRedAutoV1 {
+
+    public bRedAutoV1() {
+        PathBuilder builder = new PathBuilder();
+
+        builder
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(133.935, 83.770, Point.CARTESIAN),
+                                new Point(79.874, 117.213, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(79.874, 117.213, Point.CARTESIAN),
+                                new Point(79.874, 120.785, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(79.874, 120.785, Point.CARTESIAN),
+                                new Point(131.824, 118.349, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(131.824, 118.349, Point.CARTESIAN),
+                                new Point(79.549, 120.460, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(79.549, 120.460, Point.CARTESIAN),
+                                new Point(79.549, 128.740, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(79.549, 128.740, Point.CARTESIAN),
+                                new Point(131.337, 128.090, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(131.337, 128.090, Point.CARTESIAN),
+                                new Point(79.549, 128.740, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(79.549, 128.740, Point.CARTESIAN),
+                                new Point(79.549, 133.610, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(79.549, 133.610, Point.CARTESIAN),
+                                new Point(130.850, 133.285, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(130.850, 133.285, Point.CARTESIAN),
+                                new Point(130.201, 36.528, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 11
+                        new BezierLine(
+                                new Point(130.201, 36.528, Point.CARTESIAN),
+                                new Point(84.095, 36.203, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 12
+                        new BezierLine(
+                                new Point(84.095, 36.203, Point.CARTESIAN),
+                                new Point(84.095, 23.378, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 13
+                        new BezierLine(
+                                new Point(84.095, 23.378, Point.CARTESIAN),
+                                new Point(119.811, 23.378, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 14
+                        new BezierLine(
+                                new Point(119.811, 23.378, Point.CARTESIAN),
+                                new Point(127.603, 13.475, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 15
+                        new BezierLine(
+                                new Point(127.603, 13.475, Point.CARTESIAN),
+                                new Point(88.640, 28.248, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 16
+                        new BezierLine(
+                                new Point(88.640, 28.248, Point.CARTESIAN),
+                                new Point(87.666, 15.910, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 17
+                        new BezierLine(
+                                new Point(87.666, 15.910, Point.CARTESIAN),
+                                new Point(127.603, 12.014, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 18
+                        new BezierLine(
+                                new Point(127.603, 12.014, Point.CARTESIAN),
+                                new Point(86.692, 12.825, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 19
+                        new BezierLine(
+                                new Point(86.692, 12.825, Point.CARTESIAN),
+                                new Point(86.692, 10.390, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation()
+                .addPath(
+                        // Line 20
+                        new BezierLine(
+                                new Point(86.692, 10.390, Point.CARTESIAN),
+                                new Point(126.467, 9.903, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation();
+    }
+}

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

@@ -5,7 +5,6 @@ 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.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;
@@ -71,7 +70,6 @@ public class PoseUpdater {
     public PoseUpdater(HardwareMap hardwareMap) {
         // TODO: replace the second argument with your preferred localizer
         this(hardwareMap, new ThreeWheelLocalizer(hardwareMap));
-//        this(hardwareMap, new ThreeWheelIMULocalizer(hardwareMap));
     }
 
     /**

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

@@ -38,9 +38,9 @@ public class DriveEncoderLocalizer extends Localizer {
     private Encoder leftRear;
     private Encoder rightRear;
     private double totalHeading;
-    public static double FORWARD_TICKS_TO_INCHES = -0.6308;
+    public static double FORWARD_TICKS_TO_INCHES = 1;
-    public static double STRAFE_TICKS_TO_INCHES = 46.4839;
+    public static double STRAFE_TICKS_TO_INCHES = 1;
-    public static double TURN_TICKS_TO_RADIANS = -0.002;
+    public static double TURN_TICKS_TO_RADIANS = 1;
     public static double ROBOT_WIDTH = 1;
     public static double ROBOT_LENGTH = 1;
 

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

@@ -65,9 +65,9 @@ public class ThreeWheelIMULocalizer extends Localizer {
     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 FORWARD_TICKS_TO_INCHES = 0.0029;//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 STRAFE_TICKS_TO_INCHES = 0.0029;//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 double TURN_TICKS_TO_RADIANS = 0.0022;//8192 * 1.37795 * 2 * Math.PI * 0.5;
 
     public static boolean useIMU = true;
 
@@ -96,9 +96,9 @@ public class ThreeWheelIMULocalizer extends Localizer {
         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);
+        leftEncoderPose = new Pose(0, 6.19375, 0);
-        rightEncoderPose = new Pose(-7.625, -6.19375, 0);
+        rightEncoderPose = new Pose(0, -6.19375, 0);
-        strafeEncoderPose = new Pose(7, 1, Math.toRadians(90));
+        strafeEncoderPose = new Pose(-7, 0, Math.toRadians(90));
 
         // TODO: replace these with your encoder ports
         leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));

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

@@ -57,11 +57,8 @@ public class ThreeWheelLocalizer extends Localizer {
     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;
 
     /**
@@ -95,9 +92,9 @@ public class ThreeWheelLocalizer extends Localizer {
         strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
 
         // TODO: reverse any encoders necessary
-        leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+        //leftEncoder.setDirection(Encoder.REVERSE);
-        rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+       // rightEncoder.setDirection(Encoder.REVERSE);
-        strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+        //strafeEncoder.setDirection(Encoder.FORWARD);
 
         setStartPose(setStartPose);
         timer = new NanoTimer();

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

@@ -63,7 +63,6 @@ public class LateralTuner extends OpMode {
         telemetryA.addData("distance moved", poseUpdater.getPose().getY());
         telemetryA.addLine("The multiplier will display what your strafe ticks to inches should be to scale your current distance to " + DISTANCE + " inches.");
         telemetryA.addData("multiplier", DISTANCE / (poseUpdater.getPose().getY() / poseUpdater.getLocalizer().getLateralMultiplier()));
-
         telemetryA.update();
 
         Drawing.drawPoseHistory(dashboardPoseTracker, "#4CAF50");

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

@@ -53,14 +53,14 @@ public class FollowerConstants {
             0);
 
     // Feed forward constant added on to the translational PIDF
-    public static double translationalPIDFFeedForward = 0.015;
+    public static double translationalPIDFFeedForward = 0.00;
 
 
     // Heading error PIDF coefficients
     public static CustomPIDFCoefficients headingPIDFCoefficients = new CustomPIDFCoefficients(
-            1,
+            2,
             0,
-            .1,
+            0.025,
             0);
 
     // Feed forward constant added on to the heading 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

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

@@ -93,11 +93,13 @@ public class ForwardVelocityTuner extends OpMode {
         }
 
         telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
-        telemetryA.addLine("The robot will run at 1 power until it reaches " + DISTANCE + " inches forward.");
+//        telemetryA.addLine("The robot will run at 1 power until it reaches " + DISTANCE + " inches forward.");
-        telemetryA.addLine("Make sure you have enough room, since the robot has inertia after cutting power.");
+//        telemetryA.addLine("Make sure you have enough room, since the robot has inertia after cutting power.");
-        telemetryA.addLine("After running the distance, the robot will cut power from the drivetrain and display the forward velocity.");
+//        telemetryA.addLine("After running the distance, the robot will cut power from the drivetrain and display the forward velocity.");
-        telemetryA.addLine("Press CROSS or A on game pad 1 to stop.");
+//        telemetryA.addLine("Press CROSS or A on game pad 1 to stop.");
-        telemetryA.update();
+//
+//
+//        telemetryA.update();
 
     }
 
@@ -138,6 +140,13 @@ public class ForwardVelocityTuner extends OpMode {
                 velocities.add(currentVelocity);
                 velocities.remove(0);
             }
+            telemetryA.addData("x", poseUpdater.getPose().getX());
+            telemetryA.addData("y", poseUpdater.getPose().getY());
+            telemetryA.addData("heading", poseUpdater.getPose().getHeading());
+            telemetryA.addData("velo mag", poseUpdater.getVelocity().getMagnitude());
+            telemetryA.addData("velo ", poseUpdater.getVelocity().getTheta());
+            telemetryA.update();
+
         } else {
             double average = 0;
             for (Double velocity : velocities) {
@@ -146,7 +155,12 @@ public class ForwardVelocityTuner extends OpMode {
             average /= (double) velocities.size();
 
             telemetryA.addData("forward velocity:", average);
-            telemetryA.update();
+//            telemetryA.addData("x", poseUpdater.getPose().getX());
+//            telemetryA.addData("y", poseUpdater.getPose().getY());
+//            telemetryA.addData("heading", poseUpdater.getPose().getHeading());
+//            telemetryA.addData("velo mag", poseUpdater.getVelocity().getMagnitude());
+//            telemetryA.addData("velo ", poseUpdater.getVelocity().getTheta());
+//            telemetryA.update();
         }
     }
 }

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

@@ -119,13 +119,6 @@ public class LateralZeroPowerAccelerationTuner extends OpMode {
      */
     @Override
     public void loop() {
-
-        telemetry.addData("x",poseUpdater.getPose().getX());
-        telemetry.addData("y",poseUpdater.getPose().getY());
-        telemetry.addData("heading",poseUpdater.getPose().getHeading());
-        telemetry.addData("velo mag", poseUpdater.getVelocity().getMagnitude());
-        telemetry.addData("velo theta", poseUpdater.getVelocity().getTheta());
-
         if (gamepad1.cross || gamepad1.a) {
             requestOpModeStop();
         }

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/states/FieldStates.java

@@ -0,0 +1,18 @@
+package org.firstinspires.ftc.teamcode.states;
+
+public class FieldStates {
+
+    public enum FieldLocation {
+        BUCKET, SUBMARINE, FLOATING, TRAVELING
+    }
+
+    private FieldLocation fieldLocation;
+
+    public FieldLocation getFieldLocation() {
+        return fieldLocation;
+    }
+
+    public void setFieldLocation(FieldLocation fieldLocation) {
+        this.fieldLocation = fieldLocation;
+    }
+}

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

@@ -0,0 +1,44 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import androidx.annotation.NonNull;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+import com.acmerobotics.roadrunner.Action;
+
+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.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+
+
+/*
+    AutoLine# - This file does something of a path......
+
+ */
+public class AutoLine1 {
+
+    private PathChain pathChain;
+    private Pose autoLin1StartPose = new Pose(8,65);
+
+    public void moveToAutoLine1(Follower robot) {
+        PathBuilder builder = new PathBuilder();
+        builder
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(8.000, 65.000, Point.CARTESIAN),
+                                new Point(30.000, 72.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0));
+        pathChain = builder.build();
+        robot.setStartingPose(autoLin1StartPose);
+        robot.followPath(pathChain);
+    }
+
+}
+

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

@@ -0,0 +1,40 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import androidx.annotation.NonNull;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+import com.acmerobotics.roadrunner.Action;
+
+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.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+
+/*
+    AutoLine# - This file does something of a path......
+
+ */
+public class AutoLine2 {
+    private PathChain pathChain;
+    public void moveToAutoLine2(Follower robot) {
+        PathBuilder builder = new PathBuilder();
+        builder
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(36.000, 72.000, Point.CARTESIAN),
+                                new Point(24.000, 24.000, Point.CARTESIAN),
+                                new Point(72.000, 36.000, Point.CARTESIAN),
+                                new Point(56.000, 24.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(180));
+        pathChain = builder.build();
+        robot.followPath(pathChain);
+    }
+}
+

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

@@ -0,0 +1,73 @@
+package org.firstinspires.ftc.teamcode.subsystem;
+
+import androidx.annotation.NonNull;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+import com.acmerobotics.roadrunner.Action;
+
+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.PathBuilder;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+
+/*
+    AutoLine# - This file does something of a path......
+
+ */
+public class AutoLine3 implements Action {
+
+    private Follower actionRobot;
+    private PathChain pathChain;
+
+    private Pose startPose = new Pose(56,24);
+
+    public AutoLine3(Follower robot) {
+        this.actionRobot = robot;
+        this.actionRobot.setStartingPose(startPose);
+
+        PathBuilder builder = new PathBuilder();
+        builder
+         /*       .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(8.000, 65.000, Point.CARTESIAN),
+                                new Point(30.000, 72.000, Point.CARTESIAN)
+//           This is the origional                     new Point(36.000, 72.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .addPath(
+                        // Line 2
+                        new BezierCurve(
+                                new Point(36.000, 72.000, Point.CARTESIAN),
+                                new Point(24.000, 24.000, Point.CARTESIAN),
+                                new Point(72.000, 36.000, Point.CARTESIAN),
+                                new Point(56.000, 24.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(180))          */
+                .addPath(
+                   // Line 3
+                   new BezierLine(
+                            new Point(56.000, 24.000, Point.CARTESIAN),
+                             new Point(18.000, 24.000, Point.CARTESIAN)
+                        )
+                )
+                .setTangentHeadingInterpolation();
+
+        pathChain = builder.build();
+
+        this.actionRobot.followPath(this.pathChain);
+    }
+
+    @Override
+    public boolean run(@NonNull TelemetryPacket telemetryPacket) {
+        this.actionRobot.update();
+        return this.actionRobot.isBusy();
+    }
+}
+

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

@@ -0,0 +1,105 @@
+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 static org.firstinspires.ftc.teamcode.PedroConstants.MAX_POWER;
+
+import androidx.annotation.NonNull;
+
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
+import com.acmerobotics.roadrunner.Action;
+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 {
+        STOPPED, MOVING
+    }
+
+    public TravelState travelState;
+
+    public double power;
+
+    public MotorsSubsystem(HardwareMap hardwareMap, Telemetry telemetry) {
+        this.hardwareMap = hardwareMap;
+        this.telemetry = telemetry;
+        this.power = MAX_POWER;
+    }
+
+    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);
+
+        this.setState(TravelState.STOPPED);
+    }
+
+    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 setState(TravelState travelState) {
+        this.travelState = travelState;
+    }
+
+    public TravelState getState() {
+        return this.travelState;
+    }
+
+    public void setPower(DcMotor motor, double power) {
+        motor.setPower(power);
+        if (power < 0.05) {
+            this.setState(TravelState.MOVING);
+        } else {
+            this.setState(TravelState.STOPPED);
+        }
+    }
+}

build.dependencies.gradle

@@ -16,6 +16,9 @@ dependencies {
     implementation 'org.firstinspires.ftc:Vision:10.1.0'
     implementation 'androidx.appcompat:appcompat:1.2.0'
 
-    implementation 'com.acmerobotics.dashboard:dashboard:0.4.5'
+    implementation "com.acmerobotics.roadrunner:ftc:0.1.14"
+    implementation "com.acmerobotics.roadrunner:core:1.0.0"
+    implementation "com.acmerobotics.roadrunner:actions:1.0.0"
+    implementation "com.acmerobotics.dashboard:dashboard:0.4.16"
 }