In-flight untested red-side code

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

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

@@ -0,0 +1,135 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "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/AutoExample.java

@@ -0,0 +1,87 @@
+package org.firstinspires.ftc.teamcode;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+
+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;
+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 = "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/AutoExampleFour.java

@@ -0,0 +1,106 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AutoExample - 2 Curves/2 Lines", group = "Autonomous Pathing Tuning")
+public class AutoExampleFour extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(12,60, 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(12.000, 60.000, Point.CARTESIAN),
+                                new Point(60.000, 60.000, Point.CARTESIAN),
+                                new Point(60.000, 12.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(60.000, 12.000, Point.CARTESIAN),
+                                new Point(40.000, 12.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
+                .addPath(
+                        // Line 3
+                        new BezierCurve(
+                                new Point(40.000, 12.000, Point.CARTESIAN),
+                                new Point(35.000, 35.000, Point.CARTESIAN),
+                                new Point(12.000, 35.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(-90), Math.toRadians(-90))
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(12.000, 35.000, Point.CARTESIAN),
+                                new Point(12.000, 60.000, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(-90), 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/AutoExampleSeason2025V1.java

@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode.cometbots;
+package org.firstinspires.ftc.teamcode;
 
 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;
@@ -26,15 +25,15 @@ import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
  * @version 1.0, 3/12/2024
  */
 @Config
-@Autonomous(name = "BlueNonBasketAuto", group = "Autonomous Pathing Tuning")
-public class BlueNonBasketAuto extends OpMode {
+@Autonomous(name = "AutoExampleSeason2025V1", group = "Autonomous Pathing Tuning")
+public class AutoExampleSeason2025V1 extends OpMode {
     private Telemetry telemetryA;
 
     private Follower follower;
 
     private PathChain path;
 
-    private final Pose startPose = new Pose(10.929, 55.446, 0);
+    private final Pose startPose = new Pose(15.0, 35, 90);
 
     /**
      * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
@@ -44,93 +43,85 @@ public class BlueNonBasketAuto extends OpMode {
     public void init() {
         follower = new Follower(hardwareMap);
 
-        follower.setMaxPower(.45);
+        follower.setMaxPower(.375);
 
         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)
+                        // Line 1
+                        new BezierLine(
+                                new Point(15.000, 35.000, Point.CARTESIAN),
+                                new Point(60.000, 35.000, Point.CARTESIAN)
+                        )
                 )
-        )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 2
                         new BezierLine(
-                                new Point(36.321, 38.089, Point.CARTESIAN),
-                                new Point(59.786, 36.643, Point.CARTESIAN)
+                                new Point(60.000, 35.000, Point.CARTESIAN),
+                                new Point(60.000, 25.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 3
                         new BezierLine(
-                                new Point(59.786, 36.643, Point.CARTESIAN),
-                                new Point(59.304, 24.750, Point.CARTESIAN)
+                                new Point(60.000, 25.000, Point.CARTESIAN),
+                                new Point(15.000, 25.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 4
                         new BezierLine(
-                                new Point(59.304, 24.750, Point.CARTESIAN),
-                                new Point(13.982, 23.946, Point.CARTESIAN)
+                                new Point(15.000, 25.000, Point.CARTESIAN),
+                                new Point(60.000, 25.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 5
                         new BezierLine(
-                                new Point(13.982, 23.946, Point.CARTESIAN),
-                                new Point(59.464, 24.429, Point.CARTESIAN)
+                                new Point(60.000, 25.000, Point.CARTESIAN),
+                                new Point(60.000, 15.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 6
                         new BezierLine(
-                                new Point(59.464, 24.429, Point.CARTESIAN),
-                                new Point(58.982, 15.268, Point.CARTESIAN)
+                                new Point(60.000, 15.000, Point.CARTESIAN),
+                                new Point(15.000, 15.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 7
                         new BezierLine(
-                                new Point(58.982, 15.268, Point.CARTESIAN),
-                                new Point(13.821, 14.464, Point.CARTESIAN)
+                                new Point(15.000, 15.000, Point.CARTESIAN),
+                                new Point(60.000, 15.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 8
                         new BezierLine(
-                                new Point(13.821, 14.464, Point.CARTESIAN),
-                                new Point(58.661, 13.500, Point.CARTESIAN)
+                                new Point(60.000, 15.000, Point.CARTESIAN),
+                                new Point(60.000, 8.000, Point.CARTESIAN)
                         )
                 )
-                .setConstantHeadingInterpolation(Math.toRadians(0))
+                .setConstantHeadingInterpolation(Math.toRadians(90))
                 .addPath(
                         // Line 9
                         new BezierLine(
-                                new Point(58.661, 13.500, Point.CARTESIAN),
-                                new Point(58.339, 8.679, Point.CARTESIAN)
+                                new Point(60.000, 8.000, Point.CARTESIAN),
+                                new Point(15.000, 8.000, 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);
+                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+
+        follower.followPath(path);
 
         telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
         telemetryA.update();
@@ -144,7 +135,7 @@ public class BlueNonBasketAuto extends OpMode {
     public void loop() {
         follower.update();
         if (follower.atParametricEnd()) {
-            follower.followPath(path, true);
+            follower.followPath(path);
         }
         follower.telemetryDebug(telemetryA);
     }

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

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

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

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

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

@@ -1,9 +1,12 @@
 package org.firstinspires.ftc.teamcode;
+import static android.os.SystemClock.sleep;
 
+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 com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
 
 import org.firstinspires.ftc.robotcore.external.Telemetry;
 import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
@@ -13,16 +16,32 @@ 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 {
+/**
+ * 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(7.875, 89.357);
+    private final Pose startPose = new Pose(11.25, 95.75);
 
+    /**
+     * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+     * initializes the FTC Dashboard telemetry.
+     */
     @Override
     public void init() {
         follower = new Follower(hardwareMap);
@@ -35,76 +54,75 @@ public class PreLoadedBlueBasketAuto extends OpMode {
                 .addPath(
                         // Line 1
                         new BezierLine(
-                                new Point(8.036, 89.196, Point.CARTESIAN),
-                                new Point(10.125, 126.804, Point.CARTESIAN)
+                                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(10.125, 126.804, Point.CARTESIAN),
-                                new Point(37.607, 90.000, Point.CARTESIAN),
-                                new Point(62.357, 119.893, Point.CARTESIAN)
+                                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 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)
+                        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 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)
+                        new BezierLine(
+                                new Point(28.000, 121.500, Point.CARTESIAN),
+                                new Point(15.750, 126.321, 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)
+                        new BezierCurve(
+                                new Point(15.750, 126.321, 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(15.107, 130.339, Point.CARTESIAN),
-                                new Point(59.625, 126.964, Point.CARTESIAN)
+                                new Point(68.700, 130.500, Point.CARTESIAN),
+                                new Point(22.661, 130.821, 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)
+                        new BezierCurve(
+                                new Point(22.661, 130.821, 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(57.857, 133.071, Point.CARTESIAN),
-                                new Point(18.964, 134.679, Point.CARTESIAN)
+                                new Point(63.804, 135.321, Point.CARTESIAN),
+                                new Point(26.679, 135.964, 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)
+                        new BezierLine(
+                                new Point(26.679, 135.964, Point.CARTESIAN),
+                                new Point(83.250, 95.464, Point.CARTESIAN)
                         )
                 )
                 .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(270)).build();
@@ -114,9 +132,16 @@ public class PreLoadedBlueBasketAuto extends OpMode {
         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/BluebAutoV1.java

@@ -0,0 +1,247 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "BluebAutoV1", group = "Autonomous Pathing Tuning")
+public class BluebAutoV1 extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(7.5, 72, 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()
+                .addPath(
+                        // Line 1
+                        new BezierLine(
+                                new Point(7.5, 72, Point.CARTESIAN),
+                                new Point(29.893, 38.250, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(29.893, 38.250, Point.CARTESIAN),
+                                new Point(65.250, 32.143, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(65.250, 32.143, Point.CARTESIAN),
+                                new Point(61.714, 24.429, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(61.714, 24.429, Point.CARTESIAN),
+                                new Point(13.821, 22.821, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(13.821, 22.821, Point.CARTESIAN),
+                                new Point(61.714, 24.429, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(61.714, 24.429, Point.CARTESIAN),
+                                new Point(60.750, 12.696, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(60.750, 12.696, Point.CARTESIAN),
+                                new Point(12.375, 13.179, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(12.375, 13.179, Point.CARTESIAN),
+                                new Point(60.750, 12.536, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(60.750, 12.536, Point.CARTESIAN),
+                                new Point(60.589, 9.321, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(60.589, 9.321, Point.CARTESIAN),
+                                new Point(12.536, 8.357, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 11
+                        new BezierLine(
+                                new Point(12.536, 8.357, Point.CARTESIAN),
+                                new Point(26.679, 8.679, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 12
+                        new BezierLine(
+                                new Point(26.679, 8.679, Point.CARTESIAN),
+                                new Point(22.821, 109.446, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 13
+                        new BezierLine(
+                                new Point(22.821, 109.446, Point.CARTESIAN),
+                                new Point(70.714, 109.446, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 14
+                        new BezierLine(
+                                new Point(70.714, 109.446, Point.CARTESIAN),
+                                new Point(71.036, 120.214, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 15
+                        new BezierLine(
+                                new Point(71.036, 120.214, Point.CARTESIAN),
+                                new Point(22.179, 120.214, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 16
+                        new BezierLine(
+                                new Point(22.179, 120.214, Point.CARTESIAN),
+                                new Point(11.089, 130.821, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 17
+                        new BezierLine(
+                                new Point(11.089, 130.821, Point.CARTESIAN),
+                                new Point(70.714, 112.018, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 18
+                        new BezierLine(
+                                new Point(70.714, 112.018, Point.CARTESIAN),
+                                new Point(70.714, 128.250, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 19
+                        new BezierLine(
+                                new Point(70.714, 128.250, Point.CARTESIAN),
+                                new Point(9.964, 130.018, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 20
+                        new BezierLine(
+                                new Point(9.964, 130.018, Point.CARTESIAN),
+                                new Point(70.554, 130.500, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 21
+                        new BezierLine(
+                                new Point(70.554, 130.500, Point.CARTESIAN),
+                                new Point(70.393, 135.000, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90))
+                .addPath(
+                        // Line 22
+                        new BezierLine(
+                                new Point(70.393, 135.000, Point.CARTESIAN),
+                                new Point(13.821, 134.839, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+
+        follower.followPath(path);
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

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

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

@@ -1,24 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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,12 +10,14 @@ public class PedroConstants {
     /*
         Robot parameters
     */
+    // Turn localizer - -0.003
+
 
     // Robot motor configurations
-    public static final String FRONT_LEFT_MOTOR = "front-left";
-    public static final String BACK_LEFT_MOTOR = "back-left";
-    public static final String FRONT_RIGHT_MOTOR = "front-right";
-    public static final String BACK_RIGHT_MOTOR = "back-right";
+    public static final String FRONT_LEFT_MOTOR = "Drive front lt";
+    public static final String BACK_LEFT_MOTOR  = "Drive back lt";
+    public static final String FRONT_RIGHT_MOTOR  = "Drive front rt";
+    public static final String BACK_RIGHT_MOTOR  = "Drive back rt";
 
     // Robot motor direction
     public static final Direction FRONT_LEFT_MOTOR_DIRECTION = Direction.REVERSE;
@@ -23,55 +25,43 @@ 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.LEFT;
+            = RevHubOrientationOnRobot.LogoFacingDirection.DOWN;
     public static final RevHubOrientationOnRobot.UsbFacingDirection IMU_USB_FACING_DIRECTION
-            = RevHubOrientationOnRobot.UsbFacingDirection.UP;
+            = RevHubOrientationOnRobot.UsbFacingDirection.LEFT;
 
     // Robot encoders
-    // NOTE:  Encoders are plugged into the same ports as motors hence the weird names
-    public static final String RIGHT_ENCODER = "front-left"; //2
-    public static final String BACK_ENCODER = "front-right"; //1
-    public static final String LEFT_ENCODER = "back-right"; //0
+    public static final String LEFT_ENCODER = "encoder left";
+    public static final String RIGHT_ENCODER = "encoder right";
+    public static final String BACK_ENCODER = "encoder back";
 
     // Robot encoder direction
     public static final double LEFT_ENCODER_DIRECTION = Encoder.FORWARD;
-    public static final double RIGHT_ENCODER_DIRECTION = Encoder.REVERSE;
+    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 = 9;
+    public static final double ROBOT_WEIGHT_IN_KG = 10.5;
 
     // Maximum velocity of the robot going forward
-    public static final double ROBOT_SPEED_FORWARD = 51.5;
+    public static final double ROBOT_SPEED_FORWARD = 51.4598;
 
     // Maximum velocity of the robot going right
-    public static final double ROBOT_SPEED_LATERAL = 28.7;
+    public static final double ROBOT_SPEED_LATERAL = 28.7119;
 
     // Rate of deceleration when power is cut-off when the robot is moving forward
-    public static final double FORWARD_ZERO_POWER_ACCEL = -59.8;
+    public static final double FORWARD_ZERO_POWER_ACCEL = -59.805;
 
     // Rate of deceleration when power is cut-off when the robot is moving to the right
-    public static final double LATERAL_ZERO_POWER_ACCEL = -99.7;
+    public static final double LATERAL_ZERO_POWER_ACCEL = -99.672;
 
     // Determines how fast your robot will decelerate as a factor of how fast your robot will coast to a stop
     public static final double ZERO_POWER_ACCEL_MULT = 3.5;

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

@@ -0,0 +1,161 @@
+package org.firstinspires.ftc.teamcode;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "BlueBasketAuto", group = "Autonomous Pathing Tuning")
+public class RedBasketAuto extends OpMode {
+    private Telemetry telemetryA;
+
+    private Follower follower;
+
+    private PathChain path;
+
+    private final Pose startPose = new Pose(
+            135.6
+            , 48.05);
+
+    /**
+     * 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(136.286, 48.536, Point.CARTESIAN),
+                                new Point(102.375, 32.946, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 2
+                        new BezierLine(
+                                new Point(102.375, 32.946, Point.CARTESIAN),
+                                new Point(80.679, 31.982, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 3
+                        new BezierLine(
+                                new Point(80.679, 31.982, Point.CARTESIAN),
+                                new Point(80.679, 23.304, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 4
+                        new BezierLine(
+                                new Point(80.679, 23.304, Point.CARTESIAN),
+                                new Point(131.143, 21.536, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 5
+                        new BezierLine(
+                                new Point(131.143, 21.536, Point.CARTESIAN),
+                                new Point(81.000, 23.304, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 6
+                        new BezierLine(
+                                new Point(81.000, 23.304, Point.CARTESIAN),
+                                new Point(81.161, 13.179, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 7
+                        new BezierLine(
+                                new Point(81.161, 13.179, Point.CARTESIAN),
+                                new Point(124.554, 13.018, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 8
+                        new BezierLine(
+                                new Point(124.554, 13.018, Point.CARTESIAN),
+                                new Point(81.000, 13.018, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 9
+                        new BezierLine(
+                                new Point(81.000, 13.018, Point.CARTESIAN),
+                                new Point(80.839, 8.800, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 10
+                        new BezierLine(
+                                new Point(80.839, 8.800, Point.CARTESIAN),
+                                new Point(120.054, 8.518, Point.CARTESIAN)
+                        )
+                )
+                .setConstantHeadingInterpolation(Math.toRadians(180))
+                .addPath(
+                        // Line 11
+                        new BezierCurve(
+                                new Point(120.054, 8.518, Point.CARTESIAN),
+                                new Point(49.821, 27.643, Point.CARTESIAN),
+                                new Point(60.429, 48.214, Point.CARTESIAN)
+                        )
+                )
+                .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(90)).build();
+        follower.followPath(path);
+
+        telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+        telemetryA.update();
+    }
+
+    /**
+     * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+     * the Telemetry, as well as the FTC Dashboard.
+     */
+    @Override
+    public void loop() {
+        follower.update();
+        if (follower.atParametricEnd()) {
+            follower.followPath(path);
+        }
+        follower.telemetryDebug(telemetryA);
+    }
+}

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

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

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

@@ -1,142 +0,0 @@
-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/pedroPathing/TUNING.md

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

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

@@ -5,6 +5,7 @@ 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;
@@ -70,6 +71,7 @@ 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 = 1;
-    public static double STRAFE_TICKS_TO_INCHES = 1;
-    public static double TURN_TICKS_TO_RADIANS = 1;
+    public static double FORWARD_TICKS_TO_INCHES = -0.6308;
+    public static double STRAFE_TICKS_TO_INCHES = 46.4839;
+    public static double TURN_TICKS_TO_RADIANS = -0.002;
     public static double ROBOT_WIDTH = 1;
     public static double ROBOT_LENGTH = 1;
 

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.0029;//8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
-    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.0022;//8192 * 1.37795 * 2 * Math.PI * 0.5;
+    public static double FORWARD_TICKS_TO_INCHES = 0.004;//8192 * 1.37795 * 2 * Math.PI * 0.5008239963;
+    public static double STRAFE_TICKS_TO_INCHES = -0.0036;//8192 * 1.37795 * 2 * Math.PI * 0.5018874659;
+    public static double TURN_TICKS_TO_RADIANS = 0.0043;//8192 * 1.37795 * 2 * Math.PI * 0.5;
 
     public static boolean useIMU = true;
 
@@ -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(0, 6.19375, 0);
-        rightEncoderPose = new Pose(0, -6.19375, 0);
-        strafeEncoderPose = new Pose(-7, 0, Math.toRadians(90));
+        leftEncoderPose = new Pose(-7.625, 6.19375, 0);
+        rightEncoderPose = new Pose(-7.625, -6.19375, 0);
+        strafeEncoderPose = new Pose(7, 1, Math.toRadians(90));
 
         // TODO: replace these with your encoder ports
         leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));

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

@@ -57,8 +57,11 @@ 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;
 
     /**
@@ -80,8 +83,8 @@ public class ThreeWheelLocalizer extends Localizer {
      */
     public ThreeWheelLocalizer(HardwareMap map, Pose setStartPose) {
         // TODO: replace these with your encoder positions
-        leftEncoderPose = new Pose(0, 6.25, 0);
-        rightEncoderPose = new Pose(0, -6.25, 0);
+        leftEncoderPose = new Pose(0, 6.19375, 0);
+        rightEncoderPose = new Pose(0, -6.19375, 0);
         strafeEncoderPose = new Pose(-7, 0, Math.toRadians(90));
 
         hardwareMap = map;

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

@@ -63,6 +63,7 @@ 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/localization/tuning/LocalizationTest.java

@@ -1,9 +1,5 @@
 package org.firstinspires.ftc.teamcode.pedroPathing.localization.tuning;
 
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
-import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
 import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.leftFrontMotorName;
 import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.leftRearMotorName;
 import static org.firstinspires.ftc.teamcode.pedroPathing.tuning.FollowerConstants.rightFrontMotorName;
@@ -62,10 +58,8 @@ public class LocalizationTest extends OpMode {
         rightRear = hardwareMap.get(DcMotorEx.class, rightRearMotorName);
         rightFront = hardwareMap.get(DcMotorEx.class, rightFrontMotorName);
 
-        leftFront.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
-        leftRear.setDirection(BACK_LEFT_MOTOR_DIRECTION);
-        rightFront.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
-        rightRear.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+        leftFront.setDirection(DcMotorSimple.Direction.REVERSE);
+        leftRear.setDirection(DcMotorSimple.Direction.REVERSE);
 
         motors = Arrays.asList(leftFront, leftRear, rightFront, rightRear);
 

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.00;
+    public static double translationalPIDFFeedForward = 0.015;
 
 
     // Heading error PIDF coefficients
     public static CustomPIDFCoefficients headingPIDFCoefficients = new CustomPIDFCoefficients(
             2,
             0,
-            0.025,
+            .025,
             0);
 
     // Feed forward constant added on to the heading PIDF

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

@@ -93,13 +93,11 @@ 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("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("Press CROSS or A on game pad 1 to stop.");
-//
-//
-//        telemetryA.update();
+        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("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.update();
 
     }
 
@@ -140,13 +138,6 @@ 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) {
@@ -155,12 +146,7 @@ public class ForwardVelocityTuner extends OpMode {
             average /= (double) velocities.size();
 
             telemetryA.addData("forward velocity:", average);
-//            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();
+            telemetryA.update();
         }
     }
 }

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

@@ -119,6 +119,13 @@ 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

@@ -1,18 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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,9 +16,6 @@ dependencies {
     implementation 'org.firstinspires.ftc:Vision:10.1.0'
     implementation 'androidx.appcompat:appcompat:1.2.0'
 
-    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"
+    implementation 'com.acmerobotics.dashboard:dashboard:0.4.5'
 }