Fully Merged Presumably

Merge branch 'auto9Ball'
# Conflicts: # TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_12Ball.java
2026-01-29 15:25:12 -06:00 · 2026-01-29 15:21:33 -06:00 · 2026-01-29 15:20:02 -06:00 · 2026-01-29 14:19:01 -06:00 · 2026-01-29 13:58:27 -06:00 · 2026-01-29 11:09:55 -06:00
15 changed files with 846 additions and 572 deletions
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_Close_12Ball.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_Close_12Ball.java
@@ -1,51 +1,61 @@
 package org.firstinspires.ftc.teamcode.autonomous;

 import static org.firstinspires.ftc.teamcode.constants.Color.redAlliance;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bHGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bShoot1Tangent;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bShootH;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bShootX;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bShootY;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bXGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bYGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bh1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bh2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bh2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bh2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bt2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bt2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bt2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bx1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bx2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bx2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.bx2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.by1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.by2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.by2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.by2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rHGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rShoot1Tangent;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rShootH;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rShootX;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rShootY;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rXGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rYGate;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rh1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rh2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rh2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rh2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rt2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rt2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rt2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rx1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rx2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rx2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.rx2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.ry1;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.ry2a;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.ry2b;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.ry2c;
-import static org.firstinspires.ftc.teamcode.constants.Poses_LT_Indexed.teleStart;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bShootH;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bShootX;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bShootY;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bh4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bhPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bx4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.bxPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.by4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.byPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rShootH;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rShootX;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rShootY;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rh4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rhPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rx4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.rxPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry1;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry2a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry2b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry3a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry3b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry4a;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ry4b;
+import static org.firstinspires.ftc.teamcode.constants.Poses.ryPrep;
+import static org.firstinspires.ftc.teamcode.constants.Poses.teleStart;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.transferServo_in;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.transferServo_out;

@@ -58,15 +68,14 @@ import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
 import com.acmerobotics.roadrunner.Action;
 import com.acmerobotics.roadrunner.ParallelAction;
 import com.acmerobotics.roadrunner.Pose2d;
-import com.acmerobotics.roadrunner.SequentialAction;
 import com.acmerobotics.roadrunner.TrajectoryActionBuilder;
 import com.acmerobotics.roadrunner.TranslationalVelConstraint;
 import com.acmerobotics.roadrunner.Vector2d;
 import com.acmerobotics.roadrunner.ftc.Actions;
 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
-import com.qualcomm.robotcore.hardware.Servo;

+import org.firstinspires.ftc.teamcode.constants.Poses_V2;
 import org.firstinspires.ftc.teamcode.libs.RR.MecanumDrive;
 import org.firstinspires.ftc.teamcode.utils.Flywheel;
 import org.firstinspires.ftc.teamcode.utils.Robot;
@@ -75,13 +84,9 @@ import org.firstinspires.ftc.teamcode.utils.Spindexer;
 import org.firstinspires.ftc.teamcode.utils.Targeting;
 import org.firstinspires.ftc.teamcode.utils.Turret;

-import java.util.ArrayList;
-import java.util.List;
-
-@Autonomous(preselectTeleOp = "TeleopV3")
@Config
-public class Auto_LT_12Ball extends LinearOpMode {
-
+@Autonomous(preselectTeleOp = "TeleopV3")
+public class Auto_LT_Close_12Ball extends LinearOpMode {
    public static double shoot0Vel = 2300, shoot0Hood = 0.93;
    public static double autoSpinStartPos = 0.2;
    public static double shoot0SpinSpeedIncrease = 0.014;
@@ -89,18 +94,15 @@ public class Auto_LT_12Ball extends LinearOpMode {
    public static double spindexerSpeedIncrease = 0.02;

    public static double obeliskTurrPos = 0.53;
-    public static double gatePickupTime = 3.0;
+    public static double normalIntakeTime = 3.0;
    public static double shoot1Turr = 0.57;
    public static double shoot0XTolerance = 1.0;
-    public static double turretShootPos = 0.72;
+    public static double turretShootPos = 0.53;
    public static double shootAllTime = 1.8;
    public static double shoot0Time = 1.6;
    public static double intake1Time = 3.0;
    public static double flywheel0Time = 3.5;
-    public static double pickup1Speed = 20.0;
-    public static double pickup2Speed = 20.0;
-    public static double pickup3Speed = 20.0;
-
+    public static double pickup1Speed = 25;
    // ---- SECOND SHOT / PICKUP ----
    public static double shoot1Vel = 2300;
    public static double shoot1Hood = 0.93;
@@ -120,11 +122,6 @@ public class Auto_LT_12Ball extends LinearOpMode {
    public static double shoot1ToleranceY = 2.0;
    public static double shoot1Time = 2.0;
    public static double shootCycleTime = 2.5;
-
-    List<Boolean> s1 = new ArrayList<>();
-
-    List<Boolean> s2 = new ArrayList<>();
-    List<Boolean> s3 = new ArrayList<>();
    public int motif = 0;
    Robot robot;
    MultipleTelemetry TELE;
@@ -142,24 +139,17 @@ public class Auto_LT_12Ball extends LinearOpMode {
    private double x2b, y2b, h2b, t2b;
    private double x2c, y2c, h2c, t2c;

-    private double xShoot, yShoot, hShoot;
-    private double xGate, yGate, hGate;
-
-    private double shoot1Tangent;
-
-    // ---- OPEN GATE / MIDFIELD ----
-    private double x3, y3, h3, t3;
-
-    // ---- PICKUP 2 ----
+    private double x3a, y3a, h3a;
+    private double x3b, y3b, h3b;
    private double x4a, y4a, h4a;
    private double x4b, y4b, h4b;

-    // ---- PICKUP 3 ----
-    private double x5a, y5a, h5a;
-    private double x5b, y5b, h5b;
+    private double xShoot, yShoot, hShoot;
+    private double xGate, yGate, hGate;
+    private double xPrep, yPrep, hPrep;
+
+    private double shoot1Tangent;

-    // ---- PARK ----
-    private double xPark, yPark, hPark;

    public Action prepareShootAll(double time) {
        return new Action() {
@@ -181,12 +171,20 @@ public class Auto_LT_12Ball extends LinearOpMode {
                turret.manualSetTurret(turretShootPos);

                robot.intake.setPower(-((System.currentTimeMillis() - stamp)) / 1000);
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return (System.currentTimeMillis() - stamp) < (time * 1000);

            }
        };
    }
+
    public Action shootAll(int vel, double shootTime, double spindexSpeed) {
        return new Action() {
            int ticker = 1;
@@ -199,8 +197,8 @@ public class Auto_LT_12Ball extends LinearOpMode {

            @Override
            public boolean run(@NonNull TelemetryPacket telemetryPacket) {
-                TELE.addData("Velocity", velo);
-                TELE.addLine("shooting");
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
                TELE.update();

                flywheel.manageFlywheel(vel);
@@ -208,7 +206,7 @@ public class Auto_LT_12Ball extends LinearOpMode {

                drive.updatePoseEstimate();

-                teleStart = drive.localizer.getPose();
+                Poses_V2.teleStart = drive.localizer.getPose();

                robot.intake.setPower(-0.3);

@@ -218,6 +216,9 @@ public class Auto_LT_12Ball extends LinearOpMode {
                ticker++;

                robot.intake.setPower(0);
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();

                if (getRuntime() - stamp < shootTime) {

@@ -261,15 +262,15 @@ public class Auto_LT_12Ball extends LinearOpMode {

            @Override
            public boolean run(@NonNull TelemetryPacket telemetryPacket) {
-                TELE.addData("Velocity", velo);
-                TELE.addLine("shooting");
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
                TELE.update();

                velo = flywheel.getVelo();

                drive.updatePoseEstimate();

-                teleStart = drive.localizer.getPose();
+                Poses_V2.teleStart = drive.localizer.getPose();

                robot.intake.setPower(-0.3);

@@ -279,6 +280,9 @@ public class Auto_LT_12Ball extends LinearOpMode {
                ticker++;

                robot.intake.setPower(0);
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();

                if (getRuntime() - stamp < shootTime) {

@@ -305,7 +309,6 @@ public class Auto_LT_12Ball extends LinearOpMode {
                    return false;

                }
-
            }
        };
    }
@@ -328,6 +331,12 @@ public class Auto_LT_12Ball extends LinearOpMode {
                motif = turret.detectObelisk();

                spindexer.ballCounterLight();
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return (System.currentTimeMillis() - stamp) < (intakeTime * 1000);

@@ -375,6 +384,12 @@ public class Auto_LT_12Ball extends LinearOpMode {
                boolean yDone = posYFallback && Math.abs(currentPose.position.y - posY) < posYTolerance;

                boolean shouldFinish = timeDone || xDone || yDone;
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return !shouldFinish;

@@ -421,6 +436,12 @@ public class Auto_LT_12Ball extends LinearOpMode {
                boolean yDone = posYFallback && Math.abs(currentPose.position.y - posY) < posYTolerance;

                boolean shouldFinish = timeDone || xDone || yDone;
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return !shouldFinish;

@@ -485,6 +506,12 @@ public class Auto_LT_12Ball extends LinearOpMode {
                boolean yDone = posYFallback && Math.abs(currentPose.position.y - posY) < posYTolerance;

                boolean shouldFinish = timeDone || xDone || yDone;
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return !shouldFinish;

@@ -538,6 +565,7 @@ public class Auto_LT_12Ball extends LinearOpMode {
                targetingSettings = targeting.calculateSettings
                        (robotX, robotY, robotHeading, 0.0, false);

+
                robot.hood.setPosition(targetingSettings.hoodAngle);

                flywheel.manageFlywheel(targetingSettings.flywheelRPM);
@@ -547,6 +575,12 @@ public class Auto_LT_12Ball extends LinearOpMode {
                boolean yDone = posYFallback && Math.abs(currentPose.position.y - posY) < posYTolerance;

                boolean shouldFinish = timeDone || xDone || yDone;
+                drive.updatePoseEstimate();
+
+                teleStart = drive.localizer.getPose();
+                TELE.addData("Velocity", flywheel.getVelo());
+                TELE.addData("Hood", robot.hood.getPosition());
+                TELE.update();

                return !shouldFinish;

@@ -557,8 +591,6 @@ public class Auto_LT_12Ball extends LinearOpMode {
    @Override
    public void runOpMode() throws InterruptedException {

-        hardwareMap.get(Servo.class, "light").setPosition(0);
-
        robot = new Robot(hardwareMap);

        TELE = new MultipleTelemetry(
@@ -582,21 +614,20 @@ public class Auto_LT_12Ball extends LinearOpMode {

        drive = new MecanumDrive(hardwareMap, new Pose2d(0, 0, 0));

-        TrajectoryActionBuilder shoot0 = null;
+        robot.spin1.setPosition(autoSpinStartPos);
+        robot.spin2.setPosition(1 - autoSpinStartPos);

+        robot.transferServo.setPosition(transferServo_out);
+
+        TrajectoryActionBuilder shoot0 = null;
        TrajectoryActionBuilder pickup1 = null;
        TrajectoryActionBuilder shoot1 = null;
        TrajectoryActionBuilder pickup2 = null;
        TrajectoryActionBuilder shoot2 = null;
        TrajectoryActionBuilder pickup3 = null;
        TrajectoryActionBuilder shoot3 = null;
-        TrajectoryActionBuilder openGate = null;
-        TrajectoryActionBuilder park = null;

-        robot.spin1.setPosition(autoSpinStartPos);
-        robot.spin2.setPosition(1 - autoSpinStartPos);
-
-        robot.transferServo.setPosition(transferServo_out);
+        robot.limelight.start();

        robot.light.setPosition(1);

@@ -611,72 +642,73 @@ public class Auto_LT_12Ball extends LinearOpMode {
            if (redAlliance) {
                robot.light.setPosition(0.28);

-                // ===== FIRST SHOT =====
+                // ---- FIRST SHOT ----
                x1 = rx1;
                y1 = ry1;
                h1 = rh1;

-                // ===== PICKUP PATH =====
+                // ---- PICKUP PATH ----
                x2a = rx2a;
                y2a = ry2a;
                h2a = rh2a;
-                t2a = rt2a;
-
                x2b = rx2b;
                y2b = ry2b;
                h2b = rh2b;
-                t2b = rt2b;
-
-                x2c = rx2c;
-                y2c = ry2c;
-                h2c = rh2c;
-                t2c = rt2c;
-
-                // ===== SHOOT POSE =====
+                x3a = rx3a;
+                y3a = ry3a;
+                h3a = rh3a;
+                x3b = rx3b;
+                y3b = ry3b;
+                h3b = rh3b;
+                x4a = rx4a;
+                y4a = ry4a;
+                h4a = rh4a;
+                x4b = rx4b;
+                y4b = ry4b;
+                h4b = rh4b;
+                xPrep = rxPrep;
+                yPrep = ryPrep;
+                hPrep = rhPrep;
                xShoot = rShootX;
                yShoot = rShootY;
                hShoot = rShootH;
-                shoot1Tangent = rShoot1Tangent;

-                // ===== GATE =====
-                xGate = rXGate;
-                yGate = rYGate;
-                hGate = rHGate;

            } else {
                robot.light.setPosition(0.6);

-                // ===== FIRST SHOT =====
+                // ---- FIRST SHOT ----
                x1 = bx1;
                y1 = by1;
                h1 = bh1;

-                // ===== PICKUP PATH =====
+                // ---- PICKUP PATH ----
                x2a = bx2a;
                y2a = by2a;
                h2a = bh2a;
-                t2a = bt2a;
-
                x2b = bx2b;
                y2b = by2b;
                h2b = bh2b;
-                t2b = bt2b;
+                x3a = bx3a;
+                y3a = by3a;
+                h3a = bh3a;
+                x3b = bx3b;
+                y3b = by3b;
+                h3b = bh3b;
+                x4a = bx4a;
+                y4a = by4a;
+                h4a = bh4a;
+                x4b = bx4b;
+                y4b = by4b;
+                h4b = bh4b;

-                x2c = bx2c;
-                y2c = by2c;
-                h2c = bh2c;
-                t2c = bt2c;
-
-                // ===== SHOOT POSE =====
+                xPrep = bxPrep;
+                yPrep = byPrep;
+                hPrep = bhPrep;
                xShoot = bShootX;
                yShoot = bShootY;
                hShoot = bShootH;
-                shoot1Tangent = bShoot1Tangent;

-                // ===== GATE =====
-                xGate = bXGate;
-                yGate = bYGate;
-                hGate = bHGate;
            }

            shoot0 = drive.actionBuilder(new Pose2d(0, 0, 0))
@@ -687,29 +719,31 @@ public class Auto_LT_12Ball extends LinearOpMode {
                    .strafeToLinearHeading(new Vector2d(x2b, y2b), h2b,
                            new TranslationalVelConstraint(pickup1Speed));

-            openGate = drive.actionBuilder(new Pose2d(x2b, y2b, h2b))
-                    .setReversed(true)
-                    .splineToConstantHeading(new Vector2d(x3, y3), t3);
-
-            shoot1 = drive.actionBuilder(new Pose2d(x3, y3, h2b))
+            shoot1 = drive.actionBuilder(new Pose2d(x2b, y2b, h2b))
+                    .strafeToLinearHeading(new Vector2d(xPrep, yPrep), hPrep)
                    .strafeToLinearHeading(new Vector2d(xShoot, yShoot), hShoot);

            pickup2 = drive.actionBuilder(new Pose2d(xShoot, yShoot, hShoot))
+                    .strafeToLinearHeading(new Vector2d(x3a, y3a), h3a)
+                    .strafeToLinearHeading(new Vector2d(x3b, y3b), h3b,
+                            new TranslationalVelConstraint(pickup1Speed));
+
+            shoot2 = drive.actionBuilder(new Pose2d(x3b, y3b, h3b))
+                    .strafeToLinearHeading(new Vector2d(xPrep, yPrep), hPrep)
+                    .strafeToLinearHeading(new Vector2d(xShoot, yShoot), hShoot);
+
+            pickup3 = drive.actionBuilder(new Pose2d(x1, y1, h1))
                    .strafeToLinearHeading(new Vector2d(x4a, y4a), h4a)
                    .strafeToLinearHeading(new Vector2d(x4b, y4b), h4b,
-                            new TranslationalVelConstraint(pickup2Speed));
-            shoot2 = drive.actionBuilder(new Pose2d(x4b, y4b, h4b))
+                            new TranslationalVelConstraint(pickup1Speed));
+            shoot3 = drive.actionBuilder(new Pose2d(x4b, y4b, h4b))
+                    .strafeToLinearHeading(new Vector2d(xPrep, yPrep), hPrep)
                    .strafeToLinearHeading(new Vector2d(xShoot, yShoot), hShoot);

-            pickup3 = drive.actionBuilder(new Pose2d(xShoot, yShoot, hShoot))
-                    .strafeToLinearHeading(new Vector2d(x5a, y5a), h5a)
-                    .strafeToLinearHeading(new Vector2d(x5b, y5b), h5b,
-                            new TranslationalVelConstraint(pickup3Speed));
-            shoot3 = drive.actionBuilder(new Pose2d(x5b, y5b, h5b))
-                    .strafeToLinearHeading(new Vector2d(xShoot, yShoot), hShoot);
-            park = drive.actionBuilder(new Pose2d(xShoot, yShoot, hShoot))
-                    .strafeToLinearHeading(new Vector2d(xPark, yPark), hPark);

+
+            TELE.addData("Red?", redAlliance);
+            TELE.update();
        }

        waitForStart();
@@ -742,42 +776,23 @@ public class Auto_LT_12Ball extends LinearOpMode {
                    shootAll((int) shoot0Vel, shoot0Time, shoot0SpinSpeedIncrease)
            );

-            //WORKING SHOOT ALL for the preload
-
-            //Pickup first pile
-
            Actions.runBlocking(
-                    new SequentialAction(
-                            new ParallelAction(
-                                    pickup1.build(),
-                                    manageFlywheel(
-                                            shootAllVelocity,
-                                            shootAllHood,
-                                            pickup1Time,
-                                            x2b,
-                                            y2b,
-                                            pickup1XTolerance,
-                                            pickup1YTolerance
-                                    ),
-                                    intake(intake1Time),
-                                    detectObelisk(
-                                            obelisk1Time,
-                                            x2b,
-                                            y2c,
-                                            obelisk1XTolerance,
-                                            obelisk1YTolerance,
-                                            obeliskTurrPos
-                                    )
+                    new ParallelAction(
+                            pickup1.build(),
+                            manageFlywheel(
+                                    shootAllVelocity,
+                                    shootAllHood,
+                                    pickup1Time,
+                                    x2b,
+                                    y2b,
+                                    pickup1XTolerance,
+                                    pickup1YTolerance
                            ),
-                            new ParallelAction(
-                                    openGate.build() //TODO: Add other managing stuff here
-                            )
+                            intake(intake1Time)
+
                    )
-
            );

-            motif = turret.detectObelisk(); //Detect Obelisk if not alr
-
            Actions.runBlocking(
                    new ParallelAction(
                            manageFlywheel(
@@ -808,9 +823,99 @@ public class Auto_LT_12Ball extends LinearOpMode {

            );

-            //Shoot from first pile
+            Actions.runBlocking(
+                    new ParallelAction(
+                            pickup2.build(),
+                            manageShooterAuto(
+                                    normalIntakeTime,
+                                    x2b,
+                                    y2b,
+                                    pickup1XTolerance,
+                                    pickup1YTolerance
+                            ),
+                            intake(normalIntakeTime)
+
+                    )
+            );
+
+            Actions.runBlocking(
+                    new ParallelAction(
+                            manageFlywheelAuto(
+                                    shootCycleTime,
+                                    0.501,
+                                    0.501,
+                                    0.501,
+                                    0.501
+                            ),
+                            shoot2.build(),
+                            prepareShootAll(shootCycleTime)
+                    )
+            );
+
+            Actions.runBlocking(
+                    new ParallelAction(
+                            manageShooterAuto(
+                                    shootAllTime,
+                                    0.501,
+                                    0.501,
+                                    0.501,
+                                    0.501
+                            ),
+                            shootAllAuto(shootAllTime, spindexerSpeedIncrease)
+                    )
+
+            );
+
+            Actions.runBlocking(
+                    new ParallelAction(
+                            pickup3.build(),
+                            manageShooterAuto(
+                                    normalIntakeTime,
+                                    x2b,
+                                    y2b,
+                                    pickup1XTolerance,
+                                    pickup1YTolerance
+                            ),
+                            intake(normalIntakeTime)
+
+                    )
+            );
+
+            Actions.runBlocking(
+                    new ParallelAction(
+                            manageFlywheelAuto(
+                                    shootCycleTime,
+                                    0.501,
+                                    0.501,
+                                    0.501,
+                                    0.501
+                            ),
+                            shoot3.build(),
+                            prepareShootAll(shootCycleTime)
+                    )
+            );
+
+            Actions.runBlocking(
+                    new ParallelAction(
+                            manageShooterAuto(
+                                    shootAllTime,
+                                    0.501,
+                                    0.501,
+                                    0.501,
+                                    0.501
+                            ),
+                            shootAllAuto(shootAllTime, spindexerSpeedIncrease)
+                    )
+
+            );
+
+
+            TELE.addLine("finished");
+            TELE.update();
+
+            sleep(2000);

        }

    }
-}
+}
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_Close_GateCycle.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_Close_GateCycle.java
@@ -76,7 +76,7 @@ import org.firstinspires.ftc.teamcode.utils.Turret;

@Autonomous(preselectTeleOp = "TeleopV3")
@Config
-public class Auto_LT_Unindexed extends LinearOpMode {
+public class Auto_LT_Close_GateCycle extends LinearOpMode {

    public static double shoot0Vel = 2300, shoot0Hood = 0.93;
    public static double autoSpinStartPos = 0.2;
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/AutoClose_V3.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/AutoClose_V3.java
@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode.autonomous;
+package org.firstinspires.ftc.teamcode.autonomous.disabled;

 import static org.firstinspires.ftc.teamcode.constants.Color.*;
 import static org.firstinspires.ftc.teamcode.constants.Poses.*;
@@ -21,6 +21,7 @@ import com.acmerobotics.roadrunner.ftc.Actions;
 import com.qualcomm.hardware.limelightvision.LLResult;
 import com.qualcomm.hardware.limelightvision.LLResultTypes;
 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;

 import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit;
@@ -31,6 +32,7 @@ import org.firstinspires.ftc.teamcode.utils.Servos;

 import java.util.List;

+@Disabled
@Config
@Autonomous(preselectTeleOp = "TeleopV3")
 public class AutoClose_V3 extends LinearOpMode {
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/AutoFar_V1.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/AutoFar_V1.java
@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode.autonomous;
+package org.firstinspires.ftc.teamcode.autonomous.disabled;

 import static org.firstinspires.ftc.teamcode.constants.Color.*;
 import static org.firstinspires.ftc.teamcode.constants.Poses.*;
@@ -21,6 +21,7 @@ import com.acmerobotics.roadrunner.ftc.Actions;
 import com.qualcomm.hardware.limelightvision.LLResult;
 import com.qualcomm.hardware.limelightvision.LLResultTypes;
 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;

 import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit;
@@ -30,7 +31,9 @@ import org.firstinspires.ftc.teamcode.utils.Robot;
 import org.firstinspires.ftc.teamcode.utils.Servos;

 import java.util.List;
-
+@Disabled
+@Config
+@Autonomous

 public class AutoFar_V1 extends LinearOpMode {
    Robot robot;
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/ProtoAutoClose_V3.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/disabled/ProtoAutoClose_V3.java
@@ -1,4 +1,4 @@
-package org.firstinspires.ftc.teamcode.autonomous;
+package org.firstinspires.ftc.teamcode.autonomous.disabled;

 import static org.firstinspires.ftc.teamcode.constants.Color.redAlliance;
 import static org.firstinspires.ftc.teamcode.constants.Poses.bh1;
@@ -72,6 +72,7 @@ import com.acmerobotics.roadrunner.ftc.Actions;
 import com.qualcomm.hardware.limelightvision.LLResult;
 import com.qualcomm.hardware.limelightvision.LLResultTypes;
 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
+import com.qualcomm.robotcore.eventloop.opmode.Disabled;
 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;

 import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit;
@@ -81,7 +82,7 @@ import org.firstinspires.ftc.teamcode.utils.Robot;
 import org.firstinspires.ftc.teamcode.utils.Servos;

 import java.util.List;
-
+@Disabled
@Config
@Autonomous(preselectTeleOp = "TeleopV3")
 public class ProtoAutoClose_V3 extends LinearOpMode {
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/Color.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/Color.java
@@ -1,6 +1,11 @@
 package org.firstinspires.ftc.teamcode.constants;

+import com.acmerobotics.dashboard.config.Config;
+
+@Config
 public class Color {
    public static boolean redAlliance = true;
    public static double Light0 = 0.28, Light1 = 0.67, Light2 = 0.36, Light3 = 0.5;
+
+    public static double colorFilterAlpha = 0.15;
 }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/Poses.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/Poses.java
@@ -14,17 +14,17 @@ public class Poses {

    public static Pose2d goalPose = new Pose2d(-10, 0, 0);

-    public static double rx1 = 40, ry1 = -7, rh1 = 0;
+    public static double rx1 = 20, ry1 = 0.5, rh1 = Math.toRadians(0.1);
    public static double rx2a = 41, ry2a = 18, rh2a = Math.toRadians(140);
-    public static double rx2b = 23, ry2b = 36, rh2b = Math.toRadians(140);
+    public static double rx2b = 23, ry2b = 36, rh2b = Math.toRadians(140.1);

    public static double rx2c = 34, ry2c = 50, rh2c = Math.toRadians(140);

    public static double rx3a = 55, ry3a = 39, rh3a = Math.toRadians(140);
-    public static double rx3b = 33, ry3b = 61, rh3b = Math.toRadians(140);
+    public static double rx3b = 38, ry3b = 56, rh3b = Math.toRadians(140.1);

-    public static double rx4a = 72, ry4a = 55, rh4a = Math.toRadians(140);
-    public static double rx4b = 48, ry4b = 79, rh4b = Math.toRadians(140);
+    public static double rx4a = 72, ry4a = 65, rh4a = Math.toRadians(145);
+    public static double rx4b = 37, ry4b = 85, rh4b = Math.toRadians(145.1);

    public static double bx1 = 40, by1 = 7, bh1 = 0;
    public static double bx2a = 45, by2a = -18, bh2a = Math.toRadians(-140);
@@ -38,6 +38,13 @@ public class Poses {
    public static double bx4b = 48, by4b = -79, bh4b = Math.toRadians(-140);
    public static double rfx1 = 10, rfy1 = 0, rfh1 = 0; //TODO: test this

+    public static double rShootX = 40, rShootY = -7, rShootH = Math.toRadians(50);
+    public static double rxPrep = 45, ryPrep = 10, rhPrep = Math.toRadians(50);
+
+    public static double bShootX = 20, bShootY = 30, bShootH = Math.toRadians(140);
+    public static double bxPrep = 50, byPrep = -10, bhPrep = Math.toRadians(140);
+
+
    public static Pose2d teleStart = new Pose2d(0, 0, 0);

 }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/ServoPositions.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/ServoPositions.java
@@ -5,18 +5,21 @@ import com.acmerobotics.dashboard.config.Config;
@Config
 public class ServoPositions {

-    public static double spindexer_intakePos1 = 0;
+    public static double spindexer_intakePos1 = 0.05; //0.13;

-    public static double spindexer_intakePos2 = 0.19;//0.5;
+    public static double spindexer_intakePos2 = 0.24; //0.33;//0.5;

-    public static double spindexer_intakePos3 = 0.38;//0.66;
+    public static double spindexer_intakePos3 = 0.43; //0.53;//0.66;

-    public static double spindexer_outtakeBall3 = 0.65;
+    public static double spindexer_outtakeBall3 = 0.71; //0.65; //0.24;

-    public static double spindexer_outtakeBall2 = 0.46;
-    public static double spindexer_outtakeBall1 = 0.27;
-    public static double spinStartPos = spindexer_outtakeBall1 - 0.08;
+    public static double spindexer_outtakeBall2 = 0.53; //0.46; //0.6;
+    public static double spindexer_outtakeBall1 = 0.35; //0.27; //0.4;
+    public static double spinStartPos = spindexer_outtakeBall3 - 0.1;

+    public static double shootAllAutoSpinStartPos = 0.2;
+    public static double shootAllSpindexerSpeedIncrease = 0.02;
+    public static double shootAllTime = 1.8;

    public static double transferServo_out = 0.15;

--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libs/RR/MecanumDrive.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/libs/RR/MecanumDrive.java
@@ -5,9 +5,7 @@ import androidx.annotation.NonNull;
 import com.acmerobotics.dashboard.canvas.Canvas;
 import com.acmerobotics.dashboard.config.Config;
 import com.acmerobotics.dashboard.telemetry.TelemetryPacket;
-import com.acmerobotics.roadrunner.AccelConstraint;
-import com.acmerobotics.roadrunner.Action;
-import com.acmerobotics.roadrunner.Actions;
+import com.acmerobotics.roadrunner.*;
 import com.acmerobotics.roadrunner.AngularVelConstraint;
 import com.acmerobotics.roadrunner.DualNum;
 import com.acmerobotics.roadrunner.HolonomicController;
@@ -16,20 +14,12 @@ import com.acmerobotics.roadrunner.MinVelConstraint;
 import com.acmerobotics.roadrunner.MotorFeedforward;
 import com.acmerobotics.roadrunner.Pose2d;
 import com.acmerobotics.roadrunner.Pose2dDual;
-import com.acmerobotics.roadrunner.PoseVelocity2d;
-import com.acmerobotics.roadrunner.PoseVelocity2dDual;
 import com.acmerobotics.roadrunner.ProfileAccelConstraint;
-import com.acmerobotics.roadrunner.ProfileParams;
-import com.acmerobotics.roadrunner.Rotation2d;
 import com.acmerobotics.roadrunner.Time;
 import com.acmerobotics.roadrunner.TimeTrajectory;
 import com.acmerobotics.roadrunner.TimeTurn;
 import com.acmerobotics.roadrunner.TrajectoryActionBuilder;
-import com.acmerobotics.roadrunner.TrajectoryBuilderParams;
 import com.acmerobotics.roadrunner.TurnConstraints;
-import com.acmerobotics.roadrunner.Twist2d;
-import com.acmerobotics.roadrunner.Twist2dDual;
-import com.acmerobotics.roadrunner.Vector2d;
 import com.acmerobotics.roadrunner.VelConstraint;
 import com.acmerobotics.roadrunner.ftc.DownsampledWriter;
 import com.acmerobotics.roadrunner.ftc.Encoder;
@@ -56,131 +46,13 @@ import org.firstinspires.ftc.teamcode.libs.RR.messages.MecanumCommandMessage;
 import org.firstinspires.ftc.teamcode.libs.RR.messages.MecanumLocalizerInputsMessage;
 import org.firstinspires.ftc.teamcode.libs.RR.messages.PoseMessage;

+import java.lang.Math;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;

@Config
 public final class MecanumDrive {
-    public static Params PARAMS = new Params();
-    public final MecanumKinematics kinematics = new MecanumKinematics(
-            PARAMS.inPerTick * PARAMS.trackWidthTicks, PARAMS.inPerTick / PARAMS.lateralInPerTick);
-    public final TurnConstraints defaultTurnConstraints = new TurnConstraints(
-            PARAMS.maxAngVel, -PARAMS.maxAngAccel, PARAMS.maxAngAccel);
-    public final VelConstraint defaultVelConstraint =
-            new MinVelConstraint(Arrays.asList(
-                    kinematics.new WheelVelConstraint(PARAMS.maxWheelVel),
-                    new AngularVelConstraint(PARAMS.maxAngVel)
-            ));
-    public final AccelConstraint defaultAccelConstraint =
-            new ProfileAccelConstraint(PARAMS.minProfileAccel, PARAMS.maxProfileAccel);
-    public final DcMotorEx leftFront, leftBack, rightBack, rightFront;
-    public final VoltageSensor voltageSensor;
-    public final LazyImu lazyImu;
-    public final Localizer localizer;
-    private final LinkedList<Pose2d> poseHistory = new LinkedList<>();
-    private final DownsampledWriter estimatedPoseWriter = new DownsampledWriter("ESTIMATED_POSE", 50_000_000);
-    private final DownsampledWriter targetPoseWriter = new DownsampledWriter("TARGET_POSE", 50_000_000);
-    private final DownsampledWriter driveCommandWriter = new DownsampledWriter("DRIVE_COMMAND", 50_000_000);
-    private final DownsampledWriter mecanumCommandWriter = new DownsampledWriter("MECANUM_COMMAND", 50_000_000);
-    public MecanumDrive(HardwareMap hardwareMap, Pose2d pose) {
-        LynxFirmware.throwIfModulesAreOutdated(hardwareMap);
-
-        for (LynxModule module : hardwareMap.getAll(LynxModule.class)) {
-            module.setBulkCachingMode(LynxModule.BulkCachingMode.AUTO);
-        }
-
-        // TODO: make sure your config has motors with these names (or change them)
-        //   see https://ftc-docs.firstinspires.org/en/latest/hardware_and_software_configuration/configuring/index.html
-        leftFront = hardwareMap.get(DcMotorEx.class, "fl");
-        leftBack = hardwareMap.get(DcMotorEx.class, "bl");
-        rightBack = hardwareMap.get(DcMotorEx.class, "br");
-        rightFront = hardwareMap.get(DcMotorEx.class, "fr");
-
-        leftFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
-        leftBack.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
-        rightBack.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
-        rightFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
-
-        // TODO: reverse motor directions if needed
-        //
-        leftFront.setDirection(DcMotorSimple.Direction.REVERSE);
-
-        leftBack.setDirection(DcMotorSimple.Direction.REVERSE);
-
-        // TODO: make sure your config has an IMU with this name (can be BNO or BHI)
-        //   see https://ftc-docs.firstinspires.org/en/latest/hardware_and_software_configuration/configuring/index.html
-        lazyImu = new LazyHardwareMapImu(hardwareMap, "imu", new RevHubOrientationOnRobot(
-                PARAMS.logoFacingDirection, PARAMS.usbFacingDirection));
-
-        voltageSensor = hardwareMap.voltageSensor.iterator().next();
-
-        localizer = new PinpointLocalizer(hardwareMap, PARAMS.inPerTick, pose);
-
-        FlightRecorder.write("MECANUM_PARAMS", PARAMS);
-    }
-
-    public void setDrivePowers(PoseVelocity2d powers) {
-        MecanumKinematics.WheelVelocities<Time> wheelVels = new MecanumKinematics(1).inverse(
-                PoseVelocity2dDual.constant(powers, 1));
-
-        double maxPowerMag = 1;
-        for (DualNum<Time> power : wheelVels.all()) {
-            maxPowerMag = Math.max(maxPowerMag, power.value());
-        }
-
-        leftFront.setPower(wheelVels.leftFront.get(0) / maxPowerMag);
-        leftBack.setPower(wheelVels.leftBack.get(0) / maxPowerMag);
-        rightBack.setPower(wheelVels.rightBack.get(0) / maxPowerMag);
-        rightFront.setPower(wheelVels.rightFront.get(0) / maxPowerMag);
-    }
-
-    public PoseVelocity2d updatePoseEstimate() {
-        PoseVelocity2d vel = localizer.update();
-        poseHistory.add(localizer.getPose());
-
-        while (poseHistory.size() > 100) {
-            poseHistory.removeFirst();
-        }
-
-        estimatedPoseWriter.write(new PoseMessage(localizer.getPose()));
-
-        return vel;
-    }
-
-    private void drawPoseHistory(Canvas c) {
-        double[] xPoints = new double[poseHistory.size()];
-        double[] yPoints = new double[poseHistory.size()];
-
-        int i = 0;
-        for (Pose2d t : poseHistory) {
-            xPoints[i] = t.position.x;
-            yPoints[i] = t.position.y;
-
-            i++;
-        }
-
-        c.setStrokeWidth(1);
-        c.setStroke("#3F51B5");
-        c.strokePolyline(xPoints, yPoints);
-    }
-
-    public TrajectoryActionBuilder actionBuilder(Pose2d beginPose) {
-        return new TrajectoryActionBuilder(
-                TurnAction::new,
-                FollowTrajectoryAction::new,
-                new TrajectoryBuilderParams(
-                        1e-6,
-                        new ProfileParams(
-                                0.25, 0.1, 1e-2
-                        )
-                ),
-                beginPose, 0.0,
-                defaultTurnConstraints,
-                defaultVelConstraint, defaultAccelConstraint
-        );
-    }
-
    public static class Params {
        // IMU orientation
        // TODO: fill in these values based on
@@ -201,13 +73,13 @@ public final class MecanumDrive {
        public double kA = 0.000046;

        // path profile parameters (in inches)
-        public double maxWheelVel = 250;
+        public double maxWheelVel = 180;
        public double minProfileAccel = -40;
-        public double maxProfileAccel = 250;
+        public double maxProfileAccel = 180;

        // turn profile parameters (in radians)
-        public double maxAngVel = 4 * Math.PI; // shared with path
-        public double maxAngAccel = 4 * Math.PI;
+        public double maxAngVel = 4* Math.PI; // shared with path
+        public double maxAngAccel = 4* Math.PI;

        // path controller gains
        public double axialGain = 4;
@@ -219,6 +91,35 @@ public final class MecanumDrive {
        public double headingVelGain = 0.0; // shared with turn
    }

+    public static Params PARAMS = new Params();
+
+    public final MecanumKinematics kinematics = new MecanumKinematics(
+            PARAMS.inPerTick * PARAMS.trackWidthTicks, PARAMS.inPerTick / PARAMS.lateralInPerTick);
+
+    public final TurnConstraints defaultTurnConstraints = new TurnConstraints(
+            PARAMS.maxAngVel, -PARAMS.maxAngAccel, PARAMS.maxAngAccel);
+    public final VelConstraint defaultVelConstraint =
+            new MinVelConstraint(Arrays.asList(
+                    kinematics.new WheelVelConstraint(PARAMS.maxWheelVel),
+                    new AngularVelConstraint(PARAMS.maxAngVel)
+            ));
+    public final AccelConstraint defaultAccelConstraint =
+            new ProfileAccelConstraint(PARAMS.minProfileAccel, PARAMS.maxProfileAccel);
+
+    public final DcMotorEx leftFront, leftBack, rightBack, rightFront;
+
+    public final VoltageSensor voltageSensor;
+
+    public final LazyImu lazyImu;
+
+    public final Localizer localizer;
+    private final LinkedList<Pose2d> poseHistory = new LinkedList<>();
+
+    private final DownsampledWriter estimatedPoseWriter = new DownsampledWriter("ESTIMATED_POSE", 50_000_000);
+    private final DownsampledWriter targetPoseWriter = new DownsampledWriter("TARGET_POSE", 50_000_000);
+    private final DownsampledWriter driveCommandWriter = new DownsampledWriter("DRIVE_COMMAND", 50_000_000);
+    private final DownsampledWriter mecanumCommandWriter = new DownsampledWriter("MECANUM_COMMAND", 50_000_000);
+
    public class DriveLocalizer implements Localizer {
        public final Encoder leftFront, leftBack, rightBack, rightFront;
        public final IMU imu;
@@ -243,13 +144,13 @@ public final class MecanumDrive {
        }

        @Override
-        public Pose2d getPose() {
-            return pose;
+        public void setPose(Pose2d pose) {
+            this.pose = pose;
        }

        @Override
-        public void setPose(Pose2d pose) {
-            this.pose = pose;
+        public Pose2d getPose() {
+            return pose;
        }

        @Override
@@ -315,11 +216,64 @@ public final class MecanumDrive {
        }
    }

+    public MecanumDrive(HardwareMap hardwareMap, Pose2d pose) {
+        LynxFirmware.throwIfModulesAreOutdated(hardwareMap);
+
+        for (LynxModule module : hardwareMap.getAll(LynxModule.class)) {
+            module.setBulkCachingMode(LynxModule.BulkCachingMode.AUTO);
+        }
+
+        // TODO: make sure your config has motors with these names (or change them)
+        //   see https://ftc-docs.firstinspires.org/en/latest/hardware_and_software_configuration/configuring/index.html
+        leftFront = hardwareMap.get(DcMotorEx.class, "fl");
+        leftBack = hardwareMap.get(DcMotorEx.class, "bl");
+        rightBack = hardwareMap.get(DcMotorEx.class, "br");
+        rightFront = hardwareMap.get(DcMotorEx.class, "fr");
+
+        leftFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        leftBack.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        rightBack.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+        rightFront.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
+
+        // TODO: reverse motor directions if needed
+        //
+        leftFront.setDirection(DcMotorSimple.Direction.REVERSE);
+
+        leftBack.setDirection(DcMotorSimple.Direction.REVERSE);
+
+        // TODO: make sure your config has an IMU with this name (can be BNO or BHI)
+        //   see https://ftc-docs.firstinspires.org/en/latest/hardware_and_software_configuration/configuring/index.html
+        lazyImu = new LazyHardwareMapImu(hardwareMap, "imu", new RevHubOrientationOnRobot(
+                PARAMS.logoFacingDirection, PARAMS.usbFacingDirection));
+
+        voltageSensor = hardwareMap.voltageSensor.iterator().next();
+
+        localizer = new PinpointLocalizer(hardwareMap, PARAMS.inPerTick, pose);
+
+        FlightRecorder.write("MECANUM_PARAMS", PARAMS);
+    }
+
+    public void setDrivePowers(PoseVelocity2d powers) {
+        MecanumKinematics.WheelVelocities<Time> wheelVels = new MecanumKinematics(1).inverse(
+                PoseVelocity2dDual.constant(powers, 1));
+
+        double maxPowerMag = 1;
+        for (DualNum<Time> power : wheelVels.all()) {
+            maxPowerMag = Math.max(maxPowerMag, power.value());
+        }
+
+        leftFront.setPower(wheelVels.leftFront.get(0) / maxPowerMag);
+        leftBack.setPower(wheelVels.leftBack.get(0) / maxPowerMag);
+        rightBack.setPower(wheelVels.rightBack.get(0) / maxPowerMag);
+        rightFront.setPower(wheelVels.rightFront.get(0) / maxPowerMag);
+    }
+
    public final class FollowTrajectoryAction implements Action {
        public final TimeTrajectory timeTrajectory;
-        private final double[] xPoints, yPoints;
        private double beginTs = -1;

+        private final double[] xPoints, yPoints;
+
        public FollowTrajectoryAction(TimeTrajectory t) {
            timeTrajectory = t;

@@ -496,4 +450,51 @@ public final class MecanumDrive {
            c.fillCircle(turn.beginPose.position.x, turn.beginPose.position.y, 2);
        }
    }
+
+    public PoseVelocity2d updatePoseEstimate() {
+        PoseVelocity2d vel = localizer.update();
+        poseHistory.add(localizer.getPose());
+
+        while (poseHistory.size() > 100) {
+            poseHistory.removeFirst();
+        }
+
+        estimatedPoseWriter.write(new PoseMessage(localizer.getPose()));
+
+
+        return vel;
+    }
+
+    private void drawPoseHistory(Canvas c) {
+        double[] xPoints = new double[poseHistory.size()];
+        double[] yPoints = new double[poseHistory.size()];
+
+        int i = 0;
+        for (Pose2d t : poseHistory) {
+            xPoints[i] = t.position.x;
+            yPoints[i] = t.position.y;
+
+            i++;
+        }
+
+        c.setStrokeWidth(1);
+        c.setStroke("#3F51B5");
+        c.strokePolyline(xPoints, yPoints);
+    }
+
+    public TrajectoryActionBuilder actionBuilder(Pose2d beginPose) {
+        return new TrajectoryActionBuilder(
+                TurnAction::new,
+                FollowTrajectoryAction::new,
+                new TrajectoryBuilderParams(
+                        1e-6,
+                        new ProfileParams(
+                                0.25, 0.1, 1e-2
+                        )
+                ),
+                beginPose, 0.0,
+                defaultTurnConstraints,
+                defaultVelConstraint, defaultAccelConstraint
+        );
+    }
 }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/teleop/TeleopV3.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/teleop/TeleopV3.java
@@ -1,8 +1,13 @@
 package org.firstinspires.ftc.teamcode.teleop;

+import static org.firstinspires.ftc.teamcode.constants.Color.redAlliance;
 import static org.firstinspires.ftc.teamcode.constants.Poses.teleStart;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spinStartPos;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spindexer_intakePos1;
+import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spindexer_intakePos2;
+import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spindexer_intakePos3;
+import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spindexer_outtakeBall2;
+import static org.firstinspires.ftc.teamcode.constants.ServoPositions.spindexer_outtakeBall3;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.transferServo_in;
 import static org.firstinspires.ftc.teamcode.constants.ServoPositions.transferServo_out;
 import static org.firstinspires.ftc.teamcode.utils.Servos.spinD;
@@ -27,6 +32,7 @@ import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
 import com.qualcomm.robotcore.hardware.DcMotor;

 import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit;
+import org.firstinspires.ftc.teamcode.constants.ServoPositions;
 import org.firstinspires.ftc.teamcode.libs.RR.MecanumDrive;
 import org.firstinspires.ftc.teamcode.utils.Flywheel;
 import org.firstinspires.ftc.teamcode.utils.Robot;
@@ -122,7 +128,8 @@ public class TeleopV3 extends LinearOpMode {
    private int tickerA = 1;
    private boolean transferIn = false;
    boolean turretInterpolate = false;
-    public static double spinSpeedIncrease = 0.04;
+    public static double spinSpeedIncrease = 0.03;
+    public static int resetSpinTicks = 4;

    public static double velPrediction(double distance) {
        if (distance < 30) {
@@ -172,12 +179,24 @@ public class TeleopV3 extends LinearOpMode {

        Turret turret = new Turret(robot, TELE, robot.limelight);
        robot.light.setPosition(1);
+        while (opModeInInit()){
+            robot.limelight.start();
+            if (redAlliance) {
+                robot.limelight.pipelineSwitch(4);
+            } else {
+                robot.limelight.pipelineSwitch(2);
+            }
+        }
+
        waitForStart();
        if (isStopRequested()) return;

        robot.transferServo.setPosition(transferServo_out);

        while (opModeIsActive()) {
+            //LIMELIGHT START
+            TELE.addData("Is limelight on?", robot.limelight.getStatus());
+
            // LIGHT COLORS
            spindexer.ballCounterLight();

@@ -245,56 +264,56 @@ public class TeleopV3 extends LinearOpMode {

            }

-            if (autoSpintake) {
-
-                if (!servo.spinEqual(spindexPos) && !gamepad1.right_bumper) {
-
-
-                    robot.spin1.setPosition(spindexPos);
-                    robot.spin2.setPosition(1-spindexPos);
-
-                }
-
-                if (gamepad1.right_bumper) {
-
-                    shootAll = false;
-
-                    intakeTicker++;
-
-//                    if (intakeTicker % 20 < 2) {
+//            if (autoSpintake) {
 //
-//                        robot.spin1.setPower(-1);
-//                        robot.spin2.setPower(1);
+//                if (!servo.spinEqual(spindexPos) && !gamepad1.right_bumper) {
+//
+//
+//                    robot.spin1.setPosition(spindexPos);
+//                    robot.spin2.setPosition(1-spindexPos);
+//
+//                }
+//
+//                if (gamepad1.right_bumper) {
+//
+//                    shootAll = false;
+//
+//                    intakeTicker++;
+//
+////                    if (intakeTicker % 20 < 2) {
+////
+////                        robot.spin1.setPower(-1);
+////                        robot.spin2.setPower(1);
+////
+////                    } else if (intakeTicker % 20 < 10) {
+////                        robot.spin1.setPower(-0.5);
+////                        robot.spin2.setPower(0.5);
+////                    } else if (intakeTicker % 20 < 12) {
+////                        robot.spin1.setPower(1);
+////                        robot.spin2.setPower(-1);
+////                    } else {
+////                        robot.spin1.setPower(0.5);
+////                        robot.spin2.setPower(-0.5);
+////                    }
+//
+//                    robot.intake.setPower(1);
+//                    intakeStamp = getRuntime();
+//                    TELE.addData("Reverse?", reverse);
+//                    TELE.update();
+//                } else {
+//                    if (!servo.spinEqual(spindexPos)) {
+//                        robot.spin1.setPosition(spindexPos);
+//                        robot.spin2.setPosition(1-spindexPos);
 //
-//                    } else if (intakeTicker % 20 < 10) {
-//                        robot.spin1.setPower(-0.5);
-//                        robot.spin2.setPower(0.5);
-//                    } else if (intakeTicker % 20 < 12) {
-//                        robot.spin1.setPower(1);
-//                        robot.spin2.setPower(-1);
-//                    } else {
-//                        robot.spin1.setPower(0.5);
-//                        robot.spin2.setPower(-0.5);
 //                    }
-
-                    robot.intake.setPower(1);
-                    intakeStamp = getRuntime();
-                    TELE.addData("Reverse?", reverse);
-                    TELE.update();
-                } else {
-                    if (!servo.spinEqual(spindexPos)) {
-                        robot.spin1.setPosition(spindexPos);
-                        robot.spin2.setPosition(1-spindexPos);
-
-                    }
-
-                    spindexPos = spindexer_intakePos1;
-
-                    robot.intake.setPower(0);
-
-                    intakeTicker = 0;
-                }
-            }
+//
+//                    spindexPos = spindexer_intakePos1;
+//
+//                    robot.intake.setPower(0);
+//
+//                    intakeTicker = 0;
+//                }
+//            }

            //COLOR:

@@ -582,58 +601,96 @@ public class TeleopV3 extends LinearOpMode {
 //            }

            if (enableSpindexerManager) {
-                if (!shootAll) {
+                //if (!shootAll) {
                    spindexer.processIntake();
-                }
+                //}

                // RIGHT_BUMPER
-                if (gamepad1.right_bumper) {
+                if (gamepad1.right_bumper && intakeTicker > resetSpinTicks) {
                    robot.intake.setPower(1);
-
                } else {
                    robot.intake.setPower(0);
+
                }

                // LEFT_BUMPER
-                if (!shootAll &&
-                        (gamepad1.leftBumperWasReleased() ||
-                                gamepad1.leftBumperWasPressed() ||
-                                gamepad1.left_bumper)) {
+                if (!shootAll && gamepad1.leftBumperWasReleased()) {
                    shootStamp = getRuntime();
                    shootAll = true;

                    shooterTicker = 0;
-                    spindexPos = spinStartPos;// TODO: Change starting position based on desired order to shoot green ball

                }
-
+                intakeTicker++;
                if (shootAll) {
-
+                    intakeTicker = 0;
                    intake = false;
                    reject = false;

-                    if (getRuntime() - shootStamp < 3.5) {
+//                    if (servo.getSpinPos() < spindexer_outtakeBall2 + 0.4) {
+//
+//                        if (shooterTicker == 0){
+//                            robot.transferServo.setPosition(transferServo_out);
+//                            robot.spin1.setPosition(spinStartPos);
+//                            robot.spin2.setPosition(1-spinStartPos);
+//                            if (servo.spinEqual(spinStartPos)){
+//                                shooterTicker++;
+//                            }
+//                            TELE.addLine("starting to shoot");
+//                        } else {
+//                            robot.transferServo.setPosition(transferServo_in);
+//                            shooterTicker++;
+//                            double prevSpinPos = servo.getSpinPos();
+//                            robot.spin1.setPosition(prevSpinPos + spinSpeedIncrease);
+//                            robot.spin2.setPosition(1 - prevSpinPos - spinSpeedIncrease);
+//                            TELE.addLine("shooting");
+//                        }

-                        if (shooterTicker == 0 && !servo.spinEqual(spindexPos)){
-                            robot.spin1.setPosition(spindexPos);
-                            robot.spin2.setPosition(1-spindexPos);
-                        } else {
-                            robot.transferServo.setPosition(transferServo_in);
-                            shooterTicker++;
-                            double prevSpinPos = robot.spin1.getPosition();
-                            robot.spin1.setPosition(prevSpinPos + spinSpeedIncrease);
-                            robot.spin2.setPosition(1 - prevSpinPos - spinSpeedIncrease);
-                        }
+//                    //robot.intake.setPower(-0.3);
+//                    if (getRuntime() - shootStamp < 3.0) {
+//
+//                        if (shooterTicker == 0 && !servo.spinEqual(ServoPositions.shootAllAutoSpinStartPos)) {
+//                            robot.spin1.setPosition(ServoPositions.shootAllAutoSpinStartPos);
+//                            robot.spin2.setPosition(1 - ServoPositions.shootAllAutoSpinStartPos);
+//                        } else {
+//                            shooterTicker++;
+//                            //robot.intake.setPower(0.0);
+//                            robot.transferServo.setPosition(transferServo_in);
+//                            double prevSpinPos = robot.spin1.getPosition();
+//                            robot.spin1.setPosition(prevSpinPos + ServoPositions.shootAllSpindexerSpeedIncrease);
+//                            robot.spin2.setPosition(1 - prevSpinPos - ServoPositions.shootAllAutoSpinStartPos);
+//                        }
+//
+//                    } else {
+//                        robot.transferServo.setPosition(transferServo_out);
+//                        //spindexPos = spindexer_intakePos1;
+//                        shootAll = false;
+//                        spindexer.resetSpindexer();
+//                        spindexer.processIntake();
+//
+//                    }

+
+                    if (shooterTicker == 0) {
+                        spindexer.prepareShootAll();
+                        TELE.addLine("preparing to shoot");
+                    } else if (shooterTicker == 2) {
+                        //robot.transferServo.setPosition(transferServo_in);
+                        spindexer.shootAll();
+                        TELE.addLine("starting to shoot");
+                    } else if (!spindexer.shootAllComplete()) {
+                        robot.transferServo.setPosition(transferServo_in);
+                        TELE.addLine("shoot");
                    } else {
                        robot.transferServo.setPosition(transferServo_out);
                        //spindexPos = spindexer_intakePos1;
-
                        shootAll = false;
-
                        spindexer.resetSpindexer();
-                        spindexer.processIntake();
+                        //spindexer.processIntake();
+                        TELE.addLine("stop shooting");
                    }
+                    shooterTicker++;
+                    //spindexer.processIntake();
                }

                if (gamepad1.left_stick_button){
@@ -818,42 +875,40 @@ public class TeleopV3 extends LinearOpMode {
                hub.clearBulkCache();
            }
 //
-            TELE.addData("Spin1Green", green1 + ": " + ballIn(1));
-            TELE.addData("Spin2Green", green2 + ": " + ballIn(2));
-            TELE.addData("Spin3Green", green3 + ": " + ballIn(3));
-
-            TELE.addData("pose", drive.localizer.getPose());
-            TELE.addData("heading", drive.localizer.getPose().heading.toDouble());
-            TELE.addData("distanceToGoal", distanceToGoal);
-            TELE.addData("hood", robot.hood.getPosition());
-            TELE.addData("targetVel", vel);
-            TELE.addData("Velocity", flywheel.getVelo());
-            TELE.addData("Velo1", flywheel.velo1);
-            TELE.addData("Velo2", flywheel.velo2);
-            TELE.addData("shootOrder", shootOrder);
-            TELE.addData("oddColor", oddBallColor);
-
-            // Spindexer Debug
+//            TELE.addData("Spin1Green", green1 + ": " + ballIn(1));
+//            TELE.addData("Spin2Green", green2 + ": " + ballIn(2));
+//            TELE.addData("Spin3Green", green3 + ": " + ballIn(3));
+//
+//            TELE.addData("pose", drive.localizer.getPose());
+//            TELE.addData("heading", drive.localizer.getPose().heading.toDouble());
+//            TELE.addData("distanceToGoal", distanceToGoal);
+//            TELE.addData("hood", robot.hood.getPosition());
+//            TELE.addData("targetVel", vel);
+//            TELE.addData("Velocity", flywheel.getVelo());
+//            TELE.addData("Velo1", flywheel.velo1);
+//            TELE.addData("Velo2", flywheel.velo2);
+//            TELE.addData("shootOrder", shootOrder);
+//            TELE.addData("oddColor", oddBallColor);
+//
+//            // Spindexer Debug
            TELE.addData("spinEqual", servo.spinEqual(spindexer_intakePos1));
            TELE.addData("spinCommmandedPos", spindexer.commandedIntakePosition);
            TELE.addData("spinIntakeState", spindexer.currentIntakeState);
            TELE.addData("spinTestCounter", spindexer.counter);
            TELE.addData("autoSpintake", autoSpintake);
-            //TELE.addData("distanceRearCenter", spindexer.distanceRearCenter);
-            //TELE.addData("distanceFrontDriver", spindexer.distanceFrontDriver);
-            //TELE.addData("distanceFrontPassenger", spindexer.distanceFrontPassenger);
-            TELE.addData("shootall commanded", shootAll);
-            // Targeting Debug
-            TELE.addData("robotX", robotX);
-            TELE.addData("robotY", robotY);
-            TELE.addData("robotInchesX", targeting.robotInchesX);
-            TELE.addData( "robotInchesY", targeting.robotInchesY);
-            TELE.addData("Targeting Interpolate", turretInterpolate);
+//
+//            TELE.addData("shootall commanded", shootAll);
+//            // Targeting Debug
+//            TELE.addData("robotX", robotX);
+//            TELE.addData("robotY", robotY);
+//            TELE.addData("robotInchesX", targeting.robotInchesX);
+//            TELE.addData( "robotInchesY", targeting.robotInchesY);
+//            TELE.addData("Targeting Interpolate", turretInterpolate);
            TELE.addData("Targeting GridX", targeting.robotGridX);
            TELE.addData("Targeting GridY", targeting.robotGridY);
            TELE.addData("Targeting FlyWheel", targetingSettings.flywheelRPM);
            TELE.addData("Targeting HoodAngle", targetingSettings.hoodAngle);
-            TELE.addData("timeSinceStamp", getRuntime() - shootStamp);
+//            TELE.addData("timeSinceStamp", getRuntime() - shootStamp);

            TELE.update();

--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/tests/ColorTest.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/tests/ColorTest.java
@@ -1,5 +1,7 @@
 package org.firstinspires.ftc.teamcode.tests;

+import static org.firstinspires.ftc.teamcode.constants.Color.colorFilterAlpha;
+
 import com.acmerobotics.dashboard.FtcDashboard;
 import com.acmerobotics.dashboard.config.Config;
 import com.acmerobotics.dashboard.telemetry.MultipleTelemetry;
@@ -18,6 +20,9 @@ public class ColorTest extends LinearOpMode {
    public void runOpMode() throws InterruptedException {
        robot = new Robot(hardwareMap);
        TELE = new MultipleTelemetry(telemetry, FtcDashboard.getInstance().getTelemetry());
+        double color1Distance = 0;
+        double color2Distance = 0;
+        double color3Distance = 0;

        waitForStart();
        if (isStopRequested()) return;
@@ -26,28 +31,34 @@ public class ColorTest extends LinearOpMode {
            double green1 = robot.color1.getNormalizedColors().green;
            double blue1 = robot.color1.getNormalizedColors().blue;
            double red1 = robot.color1.getNormalizedColors().red;
+            double dist1 = robot.color1.getDistance(DistanceUnit.MM);
+            color1Distance = (colorFilterAlpha * dist1) + ((1-colorFilterAlpha) * color1Distance);

            TELE.addData("Color1 toColor", robot.color1.getNormalizedColors().toColor());
            TELE.addData("Color1 green", green1 / (green1 + blue1 + red1));
-            TELE.addData("Color1 distance (mm)", robot.color1.getDistance(DistanceUnit.MM));
+            TELE.addData("Color1 distance (mm)", color1Distance);

 // ----- COLOR 2 -----
            double green2 = robot.color2.getNormalizedColors().green;
            double blue2 = robot.color2.getNormalizedColors().blue;
            double red2 = robot.color2.getNormalizedColors().red;
+            double dist2 = robot.color2.getDistance(DistanceUnit.MM);
+            color2Distance = (colorFilterAlpha * dist2) + ((1-colorFilterAlpha) * color2Distance);

            TELE.addData("Color2 toColor", robot.color2.getNormalizedColors().toColor());
            TELE.addData("Color2 green", green2 / (green2 + blue2 + red2));
-            TELE.addData("Color2 distance (mm)", robot.color2.getDistance(DistanceUnit.MM));
+            TELE.addData("Color2 distance (mm)", color2Distance);

 // ----- COLOR 3 -----
            double green3 = robot.color3.getNormalizedColors().green;
            double blue3 = robot.color3.getNormalizedColors().blue;
            double red3 = robot.color3.getNormalizedColors().red;
+            double dist3 = robot.color3.getDistance(DistanceUnit.MM);
+            color3Distance = (colorFilterAlpha * dist3) + ((1-colorFilterAlpha) * color3Distance);

            TELE.addData("Color3 toColor", robot.color3.getNormalizedColors().toColor());
            TELE.addData("Color3 green", green3 / (green3 + blue3 + red3));
-            TELE.addData("Color3 distance (mm)", robot.color3.getDistance(DistanceUnit.MM));
+            TELE.addData("Color3 distance (mm)", color3Distance);

            TELE.update();
        }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Spindexer.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Spindexer.java
@@ -39,6 +39,11 @@ public class Spindexer {
    public double distanceFrontDriver = 0.0;
    public double distanceFrontPassenger = 0.0;

+    public double spindexerWiggle = 0.01;
+
+    public double spindexerOuttakeWiggle = 0.01;
+    private double prevPos = 0.0;
+    public double spindexerPosOffset = 0.00;
    public Types.Motif desiredMotif = Types.Motif.NONE;
    // For Use
    enum RotatedBallPositionNames {
@@ -70,9 +75,12 @@ public class Spindexer {
        SHOOT_ALL_READY
    }

+    int shootWaitCount = 0;
+
    public IntakeState currentIntakeState = IntakeState.UNKNOWN_START;
+    public IntakeState prevIntakeState = IntakeState.UNKNOWN_START;
    public int unknownColorDetect = 0;
-    enum BallColor {
+    public enum BallColor {
        UNKNOWN,
        GREEN,
        PURPLE
@@ -107,7 +115,9 @@ public class Spindexer {


    double[] outakePositions =
-            {spindexer_outtakeBall1, spindexer_outtakeBall2, spindexer_outtakeBall3};
+            {spindexer_outtakeBall1+spindexerPosOffset,
+                    spindexer_outtakeBall2+spindexerPosOffset,
+                    spindexer_outtakeBall3+spindexerPosOffset};

    double[] intakePositions =
            {spindexer_intakePos1, spindexer_intakePos2, spindexer_intakePos3};
@@ -151,12 +161,15 @@ public class Spindexer {
        int spindexerBallPos = 0;

        // Read Distances
-        distanceRearCenter = robot.color1.getDistance(DistanceUnit.MM);
-        distanceFrontDriver = robot.color2.getDistance(DistanceUnit.MM);
-        distanceFrontPassenger = robot.color3.getDistance(DistanceUnit.MM);
+        double dRearCenter = robot.color1.getDistance(DistanceUnit.MM);
+        distanceRearCenter = (colorFilterAlpha * dRearCenter) + ((1-colorFilterAlpha) * distanceRearCenter);
+        double dFrontDriver = robot.color2.getDistance(DistanceUnit.MM);
+        distanceFrontDriver = (colorFilterAlpha * dFrontDriver) + ((1-colorFilterAlpha) * distanceFrontDriver);
+        double dFrontPassenger = robot.color3.getDistance(DistanceUnit.MM);
+        distanceFrontPassenger = (colorFilterAlpha * dFrontPassenger) + ((1-colorFilterAlpha) * distanceFrontPassenger);

        // Position 1
-        if (distanceRearCenter < 43) {
+        if (distanceRearCenter < 60) {

            // Mark Ball Found
            newPos1Detection = true;
@@ -170,17 +183,17 @@ public class Spindexer {
                double gP = green / (green + red + blue);

                // FIXIT - Add filtering to improve accuracy.
-                if (gP >= 0.4) {
-                    ballPositions[commandedIntakePosition].ballColor = BallColor.PURPLE;  // purple
+                if (gP >= 0.38) {
+                    ballPositions[commandedIntakePosition].ballColor = BallColor.GREEN;  // green
                } else {
-                    ballPositions[commandedIntakePosition].ballColor = BallColor.GREEN;  // purple
+                    ballPositions[commandedIntakePosition].ballColor = BallColor.PURPLE;  // purple
                }
           }
        }
        // Position 2
        // Find which ball position this is in the spindexer
        spindexerBallPos = RotatedBallPositions[commandedIntakePosition][RotatedBallPositionNames.FRONTDRIVER.ordinal()];
-        if (distanceFrontDriver < 60) {
+        if (distanceFrontDriver < 50) {
            // reset FoundEmpty because looking for 3 in a row before reset
            ballPositions[spindexerBallPos].foundEmpty = 0;
            if (detectFrontColor) {
@@ -191,9 +204,9 @@ public class Spindexer {
                double gP = green / (green + red + blue);

                if (gP >= 0.4) {
-                    ballPositions[spindexerBallPos].ballColor = BallColor.PURPLE;  // purple
+                    ballPositions[spindexerBallPos].ballColor = BallColor.GREEN;  // green
                } else {
-                    ballPositions[spindexerBallPos].ballColor = BallColor.GREEN;  // purple
+                    ballPositions[spindexerBallPos].ballColor = BallColor.PURPLE;  // purple
                }
            }
        } else {
@@ -208,7 +221,7 @@ public class Spindexer {

        // Position 3
        spindexerBallPos = RotatedBallPositions[commandedIntakePosition][RotatedBallPositionNames.FRONTPASSENGER.ordinal()];
-        if (distanceFrontPassenger < 33) {
+        if (distanceFrontPassenger < 29) {

            // reset FoundEmpty because looking for 3 in a row before reset
            ballPositions[spindexerBallPos].foundEmpty = 0;
@@ -219,10 +232,10 @@ public class Spindexer {

                double gP = green / (green + red + blue);

-                if (gP >= 0.4) {
-                    ballPositions[spindexerBallPos].ballColor = BallColor.PURPLE;  // purple
+                if (gP >= 0.42) {
+                    ballPositions[spindexerBallPos].ballColor = BallColor.GREEN;  // green
                } else {
-                    ballPositions[spindexerBallPos].ballColor = BallColor.GREEN;  // purple
+                    ballPositions[spindexerBallPos].ballColor = BallColor.PURPLE;  // purple
                }
            }
        } else {
@@ -246,10 +259,21 @@ public class Spindexer {

        return newPos1Detection;
    }
-
-    public void moveSpindexerToPos(double pos) {
+    // Has code to unjam spindexer
+    private void moveSpindexerToPos(double pos) {
        robot.spin1.setPosition(pos);
        robot.spin2.setPosition(1-pos);
+        double currentPos = servos.getSpinPos();
+        if (!servos.spinEqual(pos) && Math.abs(prevPos - currentPos) <= 0){
+//            if (currentPos > pos){
+//                robot.spin1.setPosition(servos.getSpinPos() + 0.05);
+//                robot.spin2.setPosition(1 - servos.getSpinPos() - 0.05);
+//            } else {
+//                robot.spin1.setPosition(servos.getSpinPos() - 0.05);
+//                robot.spin2.setPosition(1 - servos.getSpinPos() + 0.05);
+//            }
+        }
+        prevPos = currentPos;
    }

    public void stopSpindexer() {
@@ -278,6 +302,10 @@ public class Spindexer {
        }
    }

+    public boolean slotIsEmpty(int slot){
+        return !ballPositions[slot].isEmpty;
+    }
+
    public boolean isFull () {
        return (!ballPositions[0].isEmpty && !ballPositions[1].isEmpty && !ballPositions[2].isEmpty);
    }
@@ -287,7 +315,7 @@ public class Spindexer {
            case UNKNOWN_START:
                // For now just set position ONE if UNKNOWN
                commandedIntakePosition = 0;
-                servos.setSpinPos(intakePositions[0]);
+                moveSpindexerToPos(intakePositions[0]);
                currentIntakeState = Spindexer.IntakeState.UNKNOWN_MOVE;
                break;
            case UNKNOWN_MOVE:
@@ -316,34 +344,32 @@ public class Spindexer {
                    currentIntakeState = Spindexer.IntakeState.FINDNEXT;
                } else {
                    // Maintain Position
-                    moveSpindexerToPos(intakePositions[commandedIntakePosition]);
+                    spindexerWiggle *= -1.0;
+                    moveSpindexerToPos(intakePositions[commandedIntakePosition]+spindexerWiggle);
                }
                break;
            case FINDNEXT:
                // Find Next Open Position and start movement
                double currentSpindexerPos = servos.getSpinPos();
                double commandedtravelDistance = 2.0;
-                //double proposedTravelDistance = Math.abs(intakePositions[0] - currentSpindexerPos);
+                double proposedTravelDistance = Math.abs(intakePositions[0] - currentSpindexerPos);
                //if (ballPositions[0].isEmpty && (proposedTravelDistance < commandedtravelDistance)) {
                if (ballPositions[0].isEmpty) {
                    // Position 1
                    commandedIntakePosition = 0;
-                    servos.setSpinPos(intakePositions[commandedIntakePosition]);
                    currentIntakeState = Spindexer.IntakeState.MOVING;
                }
-                //proposedTravelDistance = Math.abs(intakePositions[1] - currentSpindexerPos);
+                proposedTravelDistance = Math.abs(intakePositions[1] - currentSpindexerPos);
                //if (ballPositions[1].isEmpty && (proposedTravelDistance < commandedtravelDistance)) {
                if (ballPositions[1].isEmpty) {
                    // Position 2
                    commandedIntakePosition = 1;
-                    servos.setSpinPos(intakePositions[commandedIntakePosition]);
                    currentIntakeState = Spindexer.IntakeState.MOVING;
                }
-                //proposedTravelDistance = Math.abs(intakePositions[2] - currentSpindexerPos);
+                proposedTravelDistance = Math.abs(intakePositions[2] - currentSpindexerPos);
                if (ballPositions[2].isEmpty) {
                    // Position 3
                    commandedIntakePosition = 2;
-                    servos.setSpinPos(intakePositions[commandedIntakePosition]);
                    currentIntakeState = Spindexer.IntakeState.MOVING;
                }
                if (currentIntakeState != Spindexer.IntakeState.MOVING) {
@@ -374,29 +400,29 @@ public class Spindexer {
                    currentIntakeState = Spindexer.IntakeState.FINDNEXT;
                }
                // Maintain Position
-                moveSpindexerToPos(intakePositions[commandedIntakePosition]);
+                spindexerWiggle *= -1.0;
+                moveSpindexerToPos(intakePositions[commandedIntakePosition]+spindexerWiggle);
                break;

            case SHOOT_ALL_PREP:
                // We get here with function call to prepareToShootMotif
                // Stopping when we get to the new position
-                if (servos.spinEqual(intakePositions[commandedIntakePosition])) {
-                    currentIntakeState = Spindexer.IntakeState.SHOOT_ALL_READY;
-                } else {
+                commandedIntakePosition = 0;
+                if (!servos.spinEqual(outakePositions[commandedIntakePosition])) {
                    // Keep moving the spindexer
-                    moveSpindexerToPos(intakePositions[commandedIntakePosition]); // Possible error: should it be using "outakePositions" instead of "intakePositions"
+                    moveSpindexerToPos(outakePositions[commandedIntakePosition]); // Possible error: should it be using "outakePositions" instead of "intakePositions"
                }
                break;

-            case SHOOT_ALL_READY:
+            case SHOOT_ALL_READY: // Not used
                // Double Check Colors
                //detectBalls(false, false); // Minimize hardware calls
                if (ballPositions[0].isEmpty && ballPositions[1].isEmpty && ballPositions[2].isEmpty) {
                    // All ball shot move to intake state
-                    currentIntakeState = Spindexer.IntakeState.FINDNEXT;
+                    currentIntakeState = Spindexer.IntakeState.SHOOTNEXT;
                }
                // Maintain Position
-                moveSpindexerToPos(intakePositions[commandedIntakePosition]);
+                moveSpindexerToPos(outakePositions[commandedIntakePosition]);
                break;

            case SHOOTNEXT:
@@ -404,23 +430,20 @@ public class Spindexer {
                if (!ballPositions[0].isEmpty) {
                    // Position 1
                    commandedIntakePosition = 0;
-                    servos.setSpinPos(outakePositions[commandedIntakePosition]);
                    currentIntakeState = Spindexer.IntakeState.SHOOTMOVING;
-                } else if (ballPositions[1].isEmpty) { // Possible error: should it be !ballPosition[1].isEmpty?
+                } else if (!ballPositions[1].isEmpty) {
                    // Position 2
                    commandedIntakePosition = 1;
-                    servos.setSpinPos(outakePositions[commandedIntakePosition]);
                    currentIntakeState = Spindexer.IntakeState.SHOOTMOVING;
-                } else if (ballPositions[2].isEmpty) { // Possible error: should it be !ballPosition[2].isEmpty?
+                } else if (!ballPositions[2].isEmpty) {
                    // Position 3
                    commandedIntakePosition = 2;
-                    servos.setSpinPos(intakePositions[commandedIntakePosition]); // Possible error: should it be using "outakePositions" instead of "intakePositions"
                    currentIntakeState = Spindexer.IntakeState.SHOOTMOVING;
                } else {
                    // Empty return to intake state
                    currentIntakeState = IntakeState.FINDNEXT;
                }
-                moveSpindexerToPos(intakePositions[commandedIntakePosition]); // Possible error: should it be using "outakePositions" instead of "intakePositions"
+                moveSpindexerToPos(outakePositions[commandedIntakePosition]);
                break;

            case SHOOTMOVING:
@@ -429,25 +452,39 @@ public class Spindexer {
                    currentIntakeState = Spindexer.IntakeState.SHOOTWAIT;
                } else {
                    // Keep moving the spindexer
-                    moveSpindexerToPos(intakePositions[commandedIntakePosition]); // Possible error: should it be using "outakePositions" instead of "intakePositions"
+                    moveSpindexerToPos(outakePositions[commandedIntakePosition]);
                }
                break;

            case SHOOTWAIT:
+                double shootWaitMax = 4;
                // Stopping when we get to the new position
-                if (servos.spinEqual(intakePositions[commandedIntakePosition])) {
-                    currentIntakeState = Spindexer.IntakeState.INTAKE;
-                    stopSpindexer();
-                    //detectBalls(true, false);
+                if (prevIntakeState != currentIntakeState) {
+                    if (commandedIntakePosition==2) {
+                        shootWaitMax = 5;
+                    }
+                    shootWaitCount = 0;
                } else {
-                    // Keep moving the spindexer
-                    moveSpindexerToPos(intakePositions[commandedIntakePosition]);
+                    shootWaitCount++;
                }
+                // wait 10 cycles
+                if (shootWaitCount > shootWaitMax) {
+                    currentIntakeState = Spindexer.IntakeState.SHOOTNEXT;
+                    ballPositions[commandedIntakePosition].isEmpty = true;
+                    shootWaitCount = 0;
+                    //stopSpindexer();
+                    //detectBalls(true, false);
+                }
+                // Keep moving the spindexer
+                spindexerOuttakeWiggle *= -1.01;
+                moveSpindexerToPos(outakePositions[commandedIntakePosition]+spindexerOuttakeWiggle);
                break;

            default:
                // Statements to execute if no case matches
        }
+
+        prevIntakeState = currentIntakeState;
        //TELE.addData("commandedIntakePosition", commandedIntakePosition);
        //TELE.update();
        // Signal a successful intake
@@ -476,7 +513,7 @@ public class Spindexer {
                } else if (ballPositions[1].ballColor == BallColor.GREEN) {
                    return 1;
                } else {
-                    return 3;
+                    return 2;
                }
                //break;
            case PPG:
@@ -499,6 +536,25 @@ public class Spindexer {
        commandedIntakePosition = bestFitMotif();
    }

+    public void prepareShootAll(){
+        currentIntakeState = Spindexer.IntakeState.SHOOT_ALL_PREP;
+    }
+    public void shootAll () {
+        ballPositions[0].isEmpty = false;
+        ballPositions[1].isEmpty = false;
+        ballPositions[2].isEmpty = false;
+        currentIntakeState = Spindexer.IntakeState.SHOOTNEXT;
+    }
+
+    public boolean shootAllComplete ()
+    {
+        return ((currentIntakeState != Spindexer.IntakeState.SHOOT_ALL_PREP) &&
+                (currentIntakeState != Spindexer.IntakeState.SHOOT_ALL_READY) &&
+                (currentIntakeState != Spindexer.IntakeState.SHOOTMOVING) &&
+                (currentIntakeState != Spindexer.IntakeState.SHOOTNEXT) &&
+                (currentIntakeState != Spindexer.IntakeState.SHOOTWAIT));
+    }
+
    void shootAllToIntake () {
        currentIntakeState = Spindexer.IntakeState.FINDNEXT;
    }
@@ -506,4 +562,16 @@ public class Spindexer {
    public void update()
    {
    }
+
+    public BallColor GetFrontDriverColor () {
+        return ballPositions[RotatedBallPositions[commandedIntakePosition][RotatedBallPositionNames.FRONTDRIVER.ordinal()]].ballColor;
+    }
+
+    public BallColor GetFrontPassengerColor () {
+        return ballPositions[RotatedBallPositions[commandedIntakePosition][RotatedBallPositionNames.FRONTPASSENGER.ordinal()]].ballColor;
+    }
+
+    public BallColor GetRearCenterColor () {
+        return ballPositions[RotatedBallPositions[commandedIntakePosition][RotatedBallPositionNames.REARCENTER.ordinal()]].ballColor;
+    }
 }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Targeting.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Targeting.java
@@ -67,19 +67,19 @@ public class Targeting {
        KNOWNTARGETING[3][4] = new Settings (3100.0, 0.47);
        KNOWNTARGETING[3][5] = new Settings (3100.0, 0.47);
        // ROW 4
-        KNOWNTARGETING[4][0] = new Settings (4540.0, 0.1);
-        KNOWNTARGETING[4][1] = new Settings (4541.0, 0.1);
-        KNOWNTARGETING[4][2] = new Settings (4542.0, 0.1);
-        KNOWNTARGETING[4][3] = new Settings (4543.0, 0.1);
-        KNOWNTARGETING[4][4] = new Settings (4544.0, 0.1);
-        KNOWNTARGETING[4][5] = new Settings (4545.0, 0.1);
-        // ROW 1
-        KNOWNTARGETING[5][0] = new Settings (4550.0, 0.1);
-        KNOWNTARGETING[5][1] = new Settings (4551.0, 0.1);
-        KNOWNTARGETING[5][2] = new Settings (4552.0, 0.1);
-        KNOWNTARGETING[5][3] = new Settings (4553.0, 0.1);
-        KNOWNTARGETING[5][4] = new Settings (4554.0, 0.1);
-        KNOWNTARGETING[5][5] = new Settings (4555.0, 0.1);
+        KNOWNTARGETING[4][0] = new Settings (3100, 0.49);
+        KNOWNTARGETING[4][1] = new Settings (3100, 0.49);
+        KNOWNTARGETING[4][2] = new Settings (3100, 0.5);
+        KNOWNTARGETING[4][3] = new Settings (3200, 0.5);
+        KNOWNTARGETING[4][4] = new Settings (3250, 0.49);
+        KNOWNTARGETING[4][5] = new Settings (3300, 0.49);
+        // ROW 5
+        KNOWNTARGETING[5][0] = new Settings (3200, 0.48);
+        KNOWNTARGETING[5][1] = new Settings (3200, 0.48);
+        KNOWNTARGETING[5][2] = new Settings (3300, 0.48);
+        KNOWNTARGETING[5][3] = new Settings (3350, 0.48);
+        KNOWNTARGETING[5][4] = new Settings (3350, 0.48);
+        KNOWNTARGETING[5][5] = new Settings (3350, 0.48);
    }

    public Targeting()
@@ -107,61 +107,81 @@ public class Targeting {

        // Determine if we need to interpolate based on tile position.
        // if near upper or lower quarter or tile interpolate with next tile.
+        int x0 = 0;
+        int y0 = 0;
        int x1 = 0;
        int y1 = 0;
-//        interpolate = false;
-//        if ((remX > TILE_UPPER_QUARTILE) && (remY > TILE_UPPER_QUARTILE) &&
-//                (robotGridX < 5) && (robotGridY <5)) {
-//            // +X, +Y
-//            interpolate = true;
-//            x1 = robotGridX + 1;
-//            y1 = robotGridY + 1;
-//        } else if ((remX < TILE_LOWER_QUARTILE) && (remY < TILE_LOWER_QUARTILE) &&
-//                (robotGridX > 0) && (robotGridY > 0)) {
-//            // -X, -Y
-//            interpolate = true;
-//            x1 = robotGridX - 1;
-//            y1 = robotGridY - 1;
-//        } else if ((remX > TILE_UPPER_QUARTILE) && (remY < TILE_LOWER_QUARTILE) &&
-//                (robotGridX < 5) && (robotGridY > 0)) {
-//            // +X, -Y
-//            interpolate = true;
-//            x1 = robotGridX + 1;
-//            y1 = robotGridY - 1;
-//        } else if ((remX < TILE_LOWER_QUARTILE) && (remY > TILE_UPPER_QUARTILE) &&
-//                (robotGridX > 0) && (robotGridY < 5)) {
-//            // -X, +Y
-//            interpolate = true;
-//            x1 = robotGridX - 1;
-//            y1 = robotGridY + 1;
-//        } else if ((remX < TILE_LOWER_QUARTILE) && (robotGridX > 0)) {
-//            // -X, Y
-//            interpolate = true;
-//            x1 = robotGridX - 1;
-//            y1 = robotGridY;
-//        } else if ((remY < TILE_LOWER_QUARTILE) && (robotGridY > 0)) {
-//            // X, -Y
-//            interpolate = true;
-//            x1 = robotGridX;
-//            y1 = robotGridY - 1;
-//        } else if ((remX > TILE_UPPER_QUARTILE) && (robotGridX < 5)) {
-//            // +X, Y
-//            interpolate = true;
-//            x1 = robotGridX + 1;
-//            y1 = robotGridY;
-//        } else if ((remY > TILE_UPPER_QUARTILE) && (robotGridY < 5)) {
-//            // X, +Y
-//            interpolate = true;
-//            x1 = robotGridX;
-//            y1 = robotGridY + 1;
-//        }
+        interpolate = false;
+        if ((remX > TILE_UPPER_QUARTILE) && (remY > TILE_UPPER_QUARTILE) &&
+                (robotGridX < 5) && (robotGridY <5)) {
+            // +X, +Y
+            interpolate = true;
+            x0 = robotGridX;
+            x1 = robotGridX + 1;
+            y0 = robotGridY;
+            y1 = robotGridY + 1;
+        } else if ((remX < TILE_LOWER_QUARTILE) && (remY < TILE_LOWER_QUARTILE) &&
+                (robotGridX > 0) && (robotGridY > 0)) {
+            // -X, -Y
+            interpolate = true;
+            x0 = robotGridX - 1;
+            x1 = robotGridX;
+            y0 = robotGridY - 1;
+            y1 = robotGridY;
+        } else if ((remX > TILE_UPPER_QUARTILE) && (remY < TILE_LOWER_QUARTILE) &&
+                (robotGridX < 5) && (robotGridY > 0)) {
+            // +X, -Y
+            interpolate = true;
+            x0 = robotGridX;
+            x1 = robotGridX + 1;
+            y0 = robotGridY - 1;
+            y1 = robotGridY;
+        } else if ((remX < TILE_LOWER_QUARTILE) && (remY > TILE_UPPER_QUARTILE) &&
+                (robotGridX > 0) && (robotGridY < 5)) {
+            // -X, +Y
+            interpolate = true;
+            x0 = robotGridX - 1;
+            x1 = robotGridX;
+            y0 = robotGridY;
+            y1 = robotGridY + 1;
+        } else if ((remX < TILE_LOWER_QUARTILE) && (robotGridX > 0)) {
+            // -X, Y
+            interpolate = true;
+            x0 = robotGridX - 1;
+            x1 = robotGridX;
+            y0 = robotGridY;
+            y1 = robotGridY;
+        } else if ((remY < TILE_LOWER_QUARTILE) && (robotGridY > 0)) {
+            // X, -Y
+            interpolate = true;
+            x0 = robotGridX;
+            x1 = robotGridX;
+            y0 = robotGridY - 1;
+            y1 = robotGridY;
+        } else if ((remX > TILE_UPPER_QUARTILE) && (robotGridX < 5)) {
+            // +X, Y
+            interpolate = true;
+            x0 = robotGridX;
+            x1 = robotGridX + 1;
+            y0 = robotGridY;
+            y1 = robotGridY;
+        } else if ((remY > TILE_UPPER_QUARTILE) && (robotGridY < 5)) {
+            // X, +Y
+            interpolate = true;
+            x0 = robotGridX;
+            x1 = robotGridX;
+            y0 = robotGridY;
+            y1 = robotGridY + 1;
+        } else {
+            interpolate = false;
+        }

        //clamp
        robotGridX = Math.max(0, Math.min(gridX, KNOWNTARGETING[0].length - 1));
        robotGridY = Math.max(0, Math.min(gridY, KNOWNTARGETING.length - 1));

        // basic search
-        if(!interpolate) {
+        if(true) { //!interpolate) {
            if ((robotGridY < 6) && (robotGridX <6)) {
                recommendedSettings.flywheelRPM = KNOWNTARGETING[robotGridX][robotGridY].flywheelRPM;
                recommendedSettings.hoodAngle = KNOWNTARGETING[robotGridX][robotGridY].hoodAngle;
@@ -170,27 +190,29 @@ public class Targeting {
        } else {

            // bilinear interpolation
-            int x0 = robotGridX;
+            //int x0 = robotGridX;
            //int x1 = Math.min(x0 + 1, KNOWNTARGETING[0].length - 1);
-            int y0 = robotGridY;
+            //int y0 = robotGridY;
            //int y1 = Math.min(y0 + 1, KNOWNTARGETING.length - 1);

-            double x = (robotInchesX - (x0 * tileSize)) / tileSize;
-            double y = (robotInchesY - (y0 * tileSize)) / tileSize;
+//            double x = (robotInchesX - (x0 * tileSize)) / tileSize;
+//            double y = (robotInchesY - (y0 * tileSize)) / tileSize;

-            double rpm00 = KNOWNTARGETING[y0][x0].flywheelRPM;
-            double rpm10 = KNOWNTARGETING[y0][x1].flywheelRPM;
-            double rpm01 = KNOWNTARGETING[y1][x0].flywheelRPM;
-            double rpm11 = KNOWNTARGETING[y1][x1].flywheelRPM;
-
-            double angle00 = KNOWNTARGETING[y0][x0].hoodAngle;
-            double angle10 = KNOWNTARGETING[y0][x1].hoodAngle;
-            double angle01 = KNOWNTARGETING[y1][x0].hoodAngle;
-            double angle11 = KNOWNTARGETING[y1][x1].hoodAngle;
-
-            recommendedSettings.flywheelRPM = (1 - x) * (1 - y) * rpm00 + x * (1 - y) * rpm10 + (1 - x) * y * rpm01 + x * y * rpm11;
-            recommendedSettings.hoodAngle = (1 - x) * (1 - y) * angle00 + x * (1 - y) * angle10 + (1 - x) * y * angle01 + x * y * angle11;
+//            double rpm00 = KNOWNTARGETING[y0][x0].flywheelRPM;
+//            double rpm10 = KNOWNTARGETING[y0][x1].flywheelRPM;
+//            double rpm01 = KNOWNTARGETING[y1][x0].flywheelRPM;
+//            double rpm11 = KNOWNTARGETING[y1][x1].flywheelRPM;
+//
+//            double angle00 = KNOWNTARGETING[y0][x0].hoodAngle;
+//            double angle10 = KNOWNTARGETING[y0][x1].hoodAngle;
+//            double angle01 = KNOWNTARGETING[y1][x0].hoodAngle;
+//            double angle11 = KNOWNTARGETING[y1][x1].hoodAngle;

+//            recommendedSettings.flywheelRPM = (1 - x) * (1 - y) * rpm00 + x * (1 - y) * rpm10 + (1 - x) * y * rpm01 + x * y * rpm11;
+//            recommendedSettings.hoodAngle = (1 - x) * (1 - y) * angle00 + x * (1 - y) * angle10 + (1 - x) * y * angle01 + x * y * angle11;
+            // Average target tiles
+            recommendedSettings.flywheelRPM = (KNOWNTARGETING[x0][y0].flywheelRPM + KNOWNTARGETING[x1][y1].flywheelRPM)/2.0;
+            recommendedSettings.hoodAngle = (KNOWNTARGETING[x0][y0].hoodAngle + KNOWNTARGETING[x1][y1].hoodAngle)/2.0;
            return recommendedSettings;
        }
    }
--- a/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Turret.java
+++ b/TeamCode/src/main/java/org/firstinspires/ftc/teamcode/utils/Turret.java
@@ -61,12 +61,6 @@ public class Turret {
        this.TELE = tele;
        this.robot = rob;
        this.webcam = cam;
-        webcam.start();
-        if (redAlliance) {
-            webcam.pipelineSwitch(4);
-        } else {
-            webcam.pipelineSwitch(2);
-        }
        bearingPID = new PIDController(B_PID_P, B_PID_I, B_PID_D);
    }

@@ -119,17 +113,14 @@ public class Turret {
    }

    public double getTy() {
-        limelightRead();
        return ty;
    }

    public double getLimelightX() {
-        limelightRead();
        return limelightPosX;
    }

    public double getLimelightY() {
-        limelightRead();
        return limelightPosY;
    }

--- a/build.dependencies.gradle
+++ b/build.dependencies.gradle
@@ -26,10 +26,10 @@ dependencies {

    implementation 'com.bylazar:fullpanels:1.0.2' //Panels

-    implementation "com.acmerobotics.roadrunner:ftc:0.1.25"
-    implementation "com.acmerobotics.roadrunner:core:1.0.1"
-    implementation "com.acmerobotics.roadrunner:actions:1.0.1"
-    implementation "com.acmerobotics.dashboard:dashboard:0.5.1"
+    implementation "com.acmerobotics.roadrunner:ftc:0.1.25" //RR
+    implementation "com.acmerobotics.roadrunner:core:1.0.1" //RR
+    implementation "com.acmerobotics.roadrunner:actions:1.0.1" //RR
+    implementation "com.acmerobotics.dashboard:dashboard:0.5.1" //FTC Dash

    implementation 'org.ftclib.ftclib:core:2.1.1' // FTC LIB
Author	SHA1	Message	Date
KeshavAnandCode	8840205fb3	Fully Merged Presumably	2026-01-29 15:25:12 -06:00
KeshavAnandCode	6b71bb17f4	Merge branch 'auto9Ball' # Conflicts: # TeamCode/src/main/java/org/firstinspires/ftc/teamcode/autonomous/Auto_LT_12Ball.java	2026-01-29 15:21:33 -06:00
DanTheMan-byte	f8369b51ed	working teleop in progress	2026-01-29 15:20:02 -06:00
DanTheMan-byte	c1dda240d3	stash	2026-01-29 14:19:01 -06:00
DanTheMan-byte	68e4fdb14d	stash	2026-01-29 13:58:27 -06:00
abhiram vishnubhotla	66c5de1b26	Update Spindexer.java	2026-01-29 11:09:55 -06:00
Matt9150	3f4fee0e24	Add functions to get the ball color to spindexer. Attempt to make shoot all in teleop work better.	2026-01-29 09:25:39 -06:00
DanTheMan-byte	53290a5982	working auto	2026-01-28 20:22:25 -06:00
DanTheMan-byte	7ae7574703	Merge branch 'SpindexerUpgradesInWork' into auto9Ball # Conflicts: # TeamCode/src/main/java/org/firstinspires/ftc/teamcode/constants/ServoPositions.java # build.dependencies.gradle	2026-01-28 19:43:20 -06:00
DanTheMan-byte	66bb5c747f	before merge	2026-01-28 19:42:08 -06:00
DanTheMan-byte	661730ef18	stash	2026-01-28 19:31:52 -06:00
Matt9150	159b130b5f	Integrate shootAll on the Robot. This version was working except with 1 ball.	2026-01-28 17:33:37 -06:00
DanTheMan-byte	641d947ec6	last edit	2026-01-28 15:36:44 -06:00
DanTheMan-byte	5d0a569f82	spindex progress: not good	2026-01-28 15:23:17 -06:00
DanTheMan-byte	f767e82e31	changed servo positions	2026-01-28 13:38:04 -06:00
Matt9150	d088fba20a	Create shootAll state machine in spindexer and call from TeleOpV3. Experiment with averaging tiles in Targeting, which is permanently disabled at the moment.	2026-01-28 13:06:53 -06:00
Matt9150	2a45eee878	Update spindexer positions after repair.	2026-01-28 00:45:21 -06:00
DanTheMan-byte	a6fe8c14e6	@Matt please take a look at this code	2026-01-27 18:51:24 -06:00
DanTheMan-byte	2fd87c9093	@Matt please take a look at this code	2026-01-27 18:38:41 -06:00
DanTheMan-byte	1715fa96cb	updated dash version	2026-01-27 16:44:55 -06:00
DanTheMan-byte	dea9a10b08	added targeting information and unjaming code (both untested)	2026-01-27 16:36:46 -06:00