diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AsherPathV1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AsherPathV1.java
new file mode 100644
index 0000000..060548e
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AsherPathV1.java
@@ -0,0 +1,135 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AsherPathV1", group = "Autonomous Pathing Tuning")
+public class AsherPathV1 extends OpMode {
+ private Telemetry telemetryA;
+
+ private Follower follower;
+
+ private PathChain path;
+
+ private final Pose startPose = new Pose(10.0, 40, 90);
+
+ /**
+ * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+ * initializes the FTC Dashboard telemetry.
+ */
+ @Override
+ public void init() {
+ follower = new Follower(hardwareMap);
+
+ follower.setMaxPower(.4);
+
+ follower.setStartingPose(startPose);
+
+ path = follower.pathBuilder()
+ /*
+ * Only update this path
+ */
+ .addPath(
+ // Line 1
+ new BezierCurve(
+ new Point(9.757, 84.983, Point.CARTESIAN),
+ new Point(33.000, 105.000, Point.CARTESIAN),
+ new Point(80.000, 118.000, Point.CARTESIAN),
+ new Point(55.000, 120.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 2
+ new BezierCurve(
+ new Point(55.000, 120.000, Point.CARTESIAN),
+ new Point(22.000, 106.000, Point.CARTESIAN),
+ new Point(11.000, 131.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 3
+ new BezierCurve(
+ new Point(11.000, 131.000, Point.CARTESIAN),
+ new Point(75.000, 95.000, Point.CARTESIAN),
+ new Point(112.000, 132.000, Point.CARTESIAN),
+ new Point(61.000, 131.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 4
+ new BezierLine(
+ new Point(61.000, 131.000, Point.CARTESIAN),
+ new Point(11.000, 131.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 5
+ new BezierCurve(
+ new Point(11.000, 131.000, Point.CARTESIAN),
+ new Point(100.000, 118.000, Point.CARTESIAN),
+ new Point(103.000, 135.000, Point.CARTESIAN),
+ new Point(61.000, 135.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 6
+ new BezierLine(
+ new Point(61.000, 135.000, Point.CARTESIAN),
+ new Point(11.000, 131.000, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 7
+ new BezierCurve(
+ new Point(11.000, 131.000, Point.CARTESIAN),
+ new Point(113.000, 95.000, Point.CARTESIAN),
+ new Point(67.000, 95.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90)).build();
+ /*
+ * End of only update this path
+ */
+
+ follower.followPath(path);
+
+ telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+ telemetryA.update();
+ }
+
+ /**
+ * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+ * the Telemetry, as well as the FTC Dashboard.
+ */
+ @Override
+ public void loop() {
+ follower.update();
+ if (follower.atParametricEnd()) {
+ follower.followPath(path);
+ }
+ follower.telemetryDebug(telemetryA);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExample.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExample.java
new file mode 100644
index 0000000..a944187
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExample.java
@@ -0,0 +1,79 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AutoExample - Straight Path", group = "Autonomous Pathing Tuning")
+public class AutoExample extends OpMode {
+ private Telemetry telemetryA;
+
+ private Follower follower;
+
+ private PathChain path;
+
+ private final Pose startPose = new Pose(0.0, 20.0, 0);
+
+ /**
+ * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+ * initializes the FTC Dashboard telemetry.
+ */
+ @Override
+ public void init() {
+ follower = new Follower(hardwareMap);
+
+ follower.setMaxPower(.6);
+
+ follower.setStartingPose(startPose);
+
+ path = follower.pathBuilder()
+ .addPath(
+ // Line 1
+ new BezierLine(
+ new Point(0.000, 20.000, Point.CARTESIAN),
+ new Point(50.000, 20.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .build();
+
+ follower.followPath(path);
+
+ telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+ telemetryA.update();
+ }
+
+ /**
+ * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+ * the Telemetry, as well as the FTC Dashboard.
+ */
+ @Override
+ public void loop() {
+ follower.update();
+ if (follower.atParametricEnd()) {
+ follower.followPath(path);
+ }
+ follower.telemetryDebug(telemetryA);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleFour.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleFour.java
new file mode 100644
index 0000000..64e96f1
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleFour.java
@@ -0,0 +1,106 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "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);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleSeason2025V1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleSeason2025V1.java
new file mode 100644
index 0000000..632804e
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleSeason2025V1.java
@@ -0,0 +1,142 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "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(15.0, 35, 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(.375);
+
+ follower.setStartingPose(startPose);
+
+ path = follower.pathBuilder()
+ .addPath(
+ // Line 1
+ new BezierLine(
+ new Point(15.000, 35.000, Point.CARTESIAN),
+ new Point(60.000, 35.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 2
+ new BezierLine(
+ new Point(60.000, 35.000, Point.CARTESIAN),
+ new Point(60.000, 25.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 3
+ new BezierLine(
+ new Point(60.000, 25.000, Point.CARTESIAN),
+ new Point(15.000, 25.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 4
+ new BezierLine(
+ new Point(15.000, 25.000, Point.CARTESIAN),
+ new Point(60.000, 25.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 5
+ new BezierLine(
+ new Point(60.000, 25.000, Point.CARTESIAN),
+ new Point(60.000, 15.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 6
+ new BezierLine(
+ new Point(60.000, 15.000, Point.CARTESIAN),
+ new Point(15.000, 15.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 7
+ new BezierLine(
+ new Point(15.000, 15.000, Point.CARTESIAN),
+ new Point(60.000, 15.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 8
+ new BezierLine(
+ new Point(60.000, 15.000, Point.CARTESIAN),
+ new Point(60.000, 8.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(90))
+ .addPath(
+ // Line 9
+ new BezierLine(
+ new Point(60.000, 8.000, Point.CARTESIAN),
+ new Point(15.000, 8.000, 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);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleThree.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleThree.java
new file mode 100644
index 0000000..60fb0ec
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleThree.java
@@ -0,0 +1,89 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "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);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleTwo.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleTwo.java
new file mode 100644
index 0000000..0784e81
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/AutoExampleTwo.java
@@ -0,0 +1,80 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "AutoExample - Simple Curve", group = "Autonomous Pathing Tuning")
+public class AutoExampleTwo extends OpMode {
+ private Telemetry telemetryA;
+
+ private Follower follower;
+
+ private PathChain path;
+
+ private final Pose startPose = new Pose(10.0, 45, 0);
+
+ /**
+ * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+ * initializes the FTC Dashboard telemetry.
+ */
+ @Override
+ public void init() {
+ follower = new Follower(hardwareMap);
+
+ follower.setMaxPower(.4);
+
+ follower.setStartingPose(startPose);
+
+ path = follower.pathBuilder()
+ .addPath(
+ // Line 1
+ new BezierCurve(
+ new Point(10.000, 45.000, Point.CARTESIAN),
+ new Point(45.000, 45.000, Point.CARTESIAN),
+ new Point(50.000, 20.000, Point.CARTESIAN)
+ )
+ )
+ .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(-90))
+ .build();
+
+ follower.followPath(path);
+
+ telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+ telemetryA.update();
+ }
+
+ /**
+ * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+ * the Telemetry, as well as the FTC Dashboard.
+ */
+ @Override
+ public void loop() {
+ follower.update();
+ if (follower.atParametricEnd()) {
+ follower.followPath(path);
+ }
+ follower.telemetryDebug(telemetryA);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BasicOmniOpMode_Linear.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BasicOmniOpMode_Linear.java
new file mode 100644
index 0000000..c726774
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BasicOmniOpMode_Linear.java
@@ -0,0 +1,197 @@
+/* Copyright (c) 2021 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_LEFT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR;
+import static org.firstinspires.ftc.teamcode.PedroConstants.FRONT_RIGHT_MOTOR_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER_DIRECTION;
+
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.DcMotor;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.util.ElapsedTime;
+
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+
+/*
+ * This file contains an example of a Linear "OpMode".
+ * An OpMode is a 'program' that runs in either the autonomous or the teleop period of an FTC match.
+ * The names of OpModes appear on the menu of the FTC Driver Station.
+ * When a selection is made from the menu, the corresponding OpMode is executed.
+ *
+ * This particular OpMode illustrates driving a 4-motor Omni-Directional (or Holonomic) robot.
+ * This code will work with either a Mecanum-Drive or an X-Drive train.
+ * Both of these drives are illustrated at https://gm0.org/en/latest/docs/robot-design/drivetrains/holonomic.html
+ * Note that a Mecanum drive must display an X roller-pattern when viewed from above.
+ *
+ * Also note that it is critical to set the correct rotation direction for each motor. See details below.
+ *
+ * Holonomic drives provide the ability for the robot to move in three axes (directions) simultaneously.
+ * Each motion axis is controlled by one Joystick axis.
+ *
+ * 1) Axial: Driving forward and backward Left-joystick Forward/Backward
+ * 2) Lateral: Strafing right and left Left-joystick Right and Left
+ * 3) Yaw: Rotating Clockwise and counter clockwise Right-joystick Right and Left
+ *
+ * This code is written assuming that the right-side motors need to be reversed for the robot to drive forward.
+ * When you first test your robot, if it moves backward when you push the left stick forward, then you must flip
+ * the direction of all 4 motors (see code below).
+ *
+ * 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
+ */
+
+@TeleOp(name="Basic: Omni Linear OpMode", group="Linear OpMode")
+public class BasicOmniOpMode_Linear extends LinearOpMode {
+
+ // Declare OpMode members for each of the 4 motors.
+ private final ElapsedTime runtime = new ElapsedTime();
+
+ @Override
+ public void runOpMode() {
+
+ // Initialize the hardware variables. Note that the strings used here must correspond
+ // to the names assigned during the robot configuration step on the DS or RC devices.
+ DcMotor leftFrontDrive = hardwareMap.get(DcMotor.class, FRONT_LEFT_MOTOR);
+ DcMotor leftBackDrive = hardwareMap.get(DcMotor.class, BACK_LEFT_MOTOR);
+ DcMotor rightFrontDrive = hardwareMap.get(DcMotor.class, FRONT_RIGHT_MOTOR);
+ DcMotor rightBackDrive = hardwareMap.get(DcMotor.class, BACK_RIGHT_MOTOR);
+
+
+
+ // TODO: replace these with your encoder ports
+ Encoder leftEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, LEFT_ENCODER));
+ Encoder rightEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, RIGHT_ENCODER));
+ Encoder strafeEncoder = new Encoder(hardwareMap.get(DcMotorEx.class, BACK_ENCODER));
+
+ // TODO: reverse any encoders necessary
+ leftEncoder.setDirection(LEFT_ENCODER_DIRECTION);
+ rightEncoder.setDirection(RIGHT_ENCODER_DIRECTION);
+ strafeEncoder.setDirection(BACK_ENCODER_DIRECTION);
+
+ // ########################################################################################
+ // !!! IMPORTANT Drive Information. Test your motor directions. !!!!!
+ // ########################################################################################
+ // Most robots need the motors on one side to be reversed to drive forward.
+ // The motor reversals shown here are for a "direct drive" robot (the wheels turn the same direction as the motor shaft)
+ // If your robot has additional gear reductions or uses a right-angled drive, it's important to ensure
+ // that your motors are turning in the correct direction. So, start out with the reversals here, BUT
+ // when you first test your robot, push the left joystick forward and observe the direction the wheels turn.
+ // Reverse the direction (flip FORWARD <-> REVERSE ) of any wheel that runs backward
+ // Keep testing until ALL the wheels move the robot forward when you push the left joystick forward.
+ leftFrontDrive.setDirection(FRONT_LEFT_MOTOR_DIRECTION);
+ leftBackDrive.setDirection(BACK_LEFT_MOTOR_DIRECTION);
+ rightFrontDrive.setDirection(FRONT_RIGHT_MOTOR_DIRECTION);
+ rightBackDrive.setDirection(BACK_RIGHT_MOTOR_DIRECTION);
+
+ // Wait for the game to start (driver presses START)
+ telemetry.addData("Status", "Initialized");
+ telemetry.addData("Left Encoder Value", leftEncoder.getDeltaPosition());
+ telemetry.addData("Right Encoder Value", rightEncoder.getDeltaPosition());
+ telemetry.addData("Strafe Encoder Value", strafeEncoder.getDeltaPosition());
+ telemetry.update();
+
+ waitForStart();
+ runtime.reset();
+
+ // run until the end of the match (driver presses STOP)
+ while (opModeIsActive()) {
+ double max;
+
+ // POV Mode uses left joystick to go forward & strafe, and right joystick to rotate.
+ double axial = -gamepad1.left_stick_y; // Note: pushing stick forward gives negative value
+ double lateral = gamepad1.left_stick_x;
+ double yaw = gamepad1.right_stick_x;
+
+ // Combine the joystick requests for each axis-motion to determine each wheel's power.
+ // Set up a variable for each drive wheel to save the power level for telemetry.
+ double leftFrontPower = axial + lateral + yaw;
+ double rightFrontPower = axial - lateral - yaw;
+ double leftBackPower = axial - lateral + yaw;
+ double rightBackPower = axial + lateral - yaw;
+
+ // Normalize the values so no wheel power exceeds 100%
+ // This ensures that the robot maintains the desired motion.
+ max = Math.max(Math.abs(leftFrontPower), Math.abs(rightFrontPower));
+ max = Math.max(max, Math.abs(leftBackPower));
+ max = Math.max(max, Math.abs(rightBackPower));
+
+ if (max > 1.0) {
+ leftFrontPower /= max;
+ rightFrontPower /= max;
+ leftBackPower /= max;
+ rightBackPower /= max;
+ }
+
+ // This is test code:
+ //
+ // Uncomment the following code to test your motor directions.
+ // Each button should make the corresponding motor run FORWARD.
+ // 1) First get all the motors to take to correct positions on the robot
+ // by adjusting your Robot Configuration if necessary.
+ // 2) Then make sure they run in the correct direction by modifying the
+ // the setDirection() calls above.
+ // Once the correct motors move in the correct direction re-comment this code.
+
+ /*
+ leftFrontPower = gamepad1.x ? 1.0 : 0.0; // X gamepad
+ leftBackPower = gamepad1.a ? 1.0 : 0.0; // A gamepad
+ rightFrontPower = gamepad1.y ? 1.0 : 0.0; // Y gamepad
+ rightBackPower = gamepad1.b ? 1.0 : 0.0; // B gamepad
+ */
+
+ // Send calculated power to wheels
+ leftFrontDrive.setPower(leftFrontPower);
+ rightFrontDrive.setPower(rightFrontPower);
+ leftBackDrive.setPower(leftBackPower);
+ rightBackDrive.setPower(rightBackPower);
+
+ // Show the elapsed game time and wheel power.
+ telemetry.addData("Status", "Run Time: " + runtime.toString());
+ telemetry.addData("Front left/Right", "%4.2f, %4.2f", leftFrontPower, rightFrontPower);
+ telemetry.addData("Back left/Right", "%4.2f, %4.2f", leftBackPower, rightBackPower);
+ telemetry.addData("Left Encoder Value", leftEncoder.getDeltaPosition());
+ telemetry.addData("Right Encoder Value", rightEncoder.getDeltaPosition());
+ telemetry.addData("Strafe Encoder Value", strafeEncoder.getDeltaPosition());
+ telemetry.update();
+ }
+ }}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BlueBasketAuto.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BlueBasketAuto.java
new file mode 100644
index 0000000..c596660
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BlueBasketAuto.java
@@ -0,0 +1,161 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierCurve;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "BlueBasketAuto", group = "Autonomous Pathing Tuning")
+public class BlueBasketAuto extends OpMode {
+ private Telemetry telemetryA;
+
+ private Follower follower;
+
+ private PathChain path;
+
+ private final Pose startPose = new Pose(11.25, 95.75);
+
+ /**
+ * This initializes the Follower and creates the PathChain for the "circle". Additionally, this
+ * initializes the FTC Dashboard telemetry.
+ */
+ @Override
+ public void init() {
+ follower = new Follower(hardwareMap);
+
+ follower.setMaxPower(.45);
+
+ follower.setStartingPose(startPose);
+
+ path = follower.pathBuilder()
+ .addPath(
+ // Line 1
+ new BezierLine(
+ new Point(11.250, 95.750, Point.CARTESIAN),
+ new Point(37.000, 108.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 2
+ new BezierCurve(
+ new Point(37.000, 108.000, Point.CARTESIAN),
+ new Point(73.286, 111.536, Point.CARTESIAN),
+ new Point(67.821, 120.536, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 3
+ new BezierLine(
+ new Point(67.821, 120.536, Point.CARTESIAN),
+ new Point(28.000, 121.500, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 4
+ new BezierLine(
+ new Point(28.000, 121.500, Point.CARTESIAN),
+ new Point(18.000, 130.179, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 5
+ new BezierCurve(
+ new Point(18.000, 130.179, Point.CARTESIAN),
+ new Point(59.000, 102.500, Point.CARTESIAN),
+ new Point(68.700, 130.500, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 6
+ new BezierLine(
+ new Point(68.700, 130.500, Point.CARTESIAN),
+ new Point(18.000, 130.339, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 7
+ new BezierCurve(
+ new Point(18.000, 130.339, Point.CARTESIAN),
+ new Point(49.018, 121.179, Point.CARTESIAN),
+ new Point(63.804, 135.321, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 8
+ new BezierLine(
+ new Point(63.804, 135.321, Point.CARTESIAN),
+ new Point(53.036, 135.161, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 9
+ new BezierLine(
+ new Point(53.036, 135.161, Point.CARTESIAN),
+ new Point(18.643, 135.000, Point.CARTESIAN)
+ )
+ )
+ .setConstantHeadingInterpolation(Math.toRadians(0))
+ .addPath(
+ // Line 10
+ new BezierLine(
+ new Point(18.643, 135.000, Point.CARTESIAN),
+ new Point(72.300, 97.400, Point.CARTESIAN)
+ )
+ )
+ .addPath(
+ // Line 9
+ new BezierLine(
+ new Point(18.643, 135.000, Point.CARTESIAN),
+ new Point(83.250, 95.464, Point.CARTESIAN)
+ )
+ )
+ .setLinearHeadingInterpolation(Math.toRadians(0), Math.toRadians(270)).build();
+ follower.followPath(path);
+
+ telemetryA = new MultipleTelemetry(this.telemetry, FtcDashboard.getInstance().getTelemetry());
+ telemetryA.update();
+ }
+
+ /**
+ * This runs the OpMode, updating the Follower as well as printing out the debug statements to
+ * the Telemetry, as well as the FTC Dashboard.
+ */
+ @Override
+ public void loop() {
+ follower.update();
+ if (follower.atParametricEnd()) {
+ follower.followPath(path);
+ }
+ follower.telemetryDebug(telemetryA);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluebAutoV1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluebAutoV1.java
new file mode 100644
index 0000000..778c4c8
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluebAutoV1.java
@@ -0,0 +1,246 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import com.acmerobotics.dashboard.FtcDashboard;
+import com.acmerobotics.dashboard.config.Config;
+import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
+import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.OpMode;
+
+import org.firstinspires.ftc.robotcore.external.Telemetry;
+import org.firstinspires.ftc.teamcode.pedroPathing.follower.Follower;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Pose;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.BezierLine;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.PathChain;
+import org.firstinspires.ftc.teamcode.pedroPathing.pathGeneration.Point;
+
+/**
+ * This is the Circle autonomous OpMode. It runs the robot in a PathChain that's actually not quite
+ * a circle, but some Bezier curves that have control points set essentially in a square. However,
+ * it turns enough to tune your centripetal force correction and some of your heading. Some lag in
+ * heading is to be expected.
+ *
+ * @author Anyi Lin - 10158 Scott's Bots
+ * @author Aaron Yang - 10158 Scott's Bots
+ * @author Harrison Womack - 10158 Scott's Bots
+ * @version 1.0, 3/12/2024
+ */
+@Config
+@Autonomous(name = "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);
+ }
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluenbAutov1.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluenbAutov1.java
new file mode 100644
index 0000000..039e835
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/BluenbAutov1.java
@@ -0,0 +1,4 @@
+package org.firstinspires.ftc.teamcode.cometbots;
+
+public class BluenbAutov1 {
+}
diff --git a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/SensorIMUOrthogonal.java b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/SensorIMUOrthogonal.java
new file mode 100644
index 0000000..6473172
--- /dev/null
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/cometbots/SensorIMUOrthogonal.java
@@ -0,0 +1,172 @@
+/* Copyright (c) 2022 FIRST. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted (subject to the limitations in the disclaimer below) provided that
+ * the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this list
+ * of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice, this
+ * list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * Neither the name of FIRST nor the names of its contributors may be used to endorse or
+ * promote products derived from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS
+ * LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.firstinspires.ftc.teamcode.cometbots;
+
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.BACK_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.IMU_LOGO_FACING_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.IMU_USB_FACING_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.LEFT_ENCODER_DIRECTION;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER;
+import static org.firstinspires.ftc.teamcode.PedroConstants.RIGHT_ENCODER_DIRECTION;
+
+import com.qualcomm.hardware.rev.RevHubOrientationOnRobot;
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
+import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
+import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
+import com.qualcomm.robotcore.hardware.DcMotorEx;
+import com.qualcomm.robotcore.hardware.IMU;
+
+import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
+import org.firstinspires.ftc.robotcore.external.navigation.AngularVelocity;
+import org.firstinspires.ftc.robotcore.external.navigation.YawPitchRollAngles;
+import org.firstinspires.ftc.teamcode.PedroConstants;
+import org.firstinspires.ftc.teamcode.pedroPathing.localization.Encoder;
+
+/*
+ * This OpMode shows how to use the new universal IMU interface. This
+ * interface may be used with the BNO055 IMU or the BHI260 IMU. It assumes that an IMU is configured
+ * on the robot with the name "imu".
+ *
+ * The sample will display the current Yaw, Pitch and Roll of the robot.
+ * 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)
+ * Roll value should INCREASE as the robot is tipped UP at the left side. (Rotation about Y)
+ * Yaw value should INCREASE as the robot is rotated Counter Clockwise. (Rotation about Z)
+ *
+ * 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:
+ * FORWARD, BACKWARD, UP, DOWN, LEFT and RIGHT.
+ *
+ * So, To fully define how your Hub is mounted to the robot, you must simply specify:
+ * logoFacingDirection
+ * 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();
+ }
+ }
+}