diff --git a/build.gradle.kts b/build.gradle.kts
index 66b3c0d..58faaf0 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -75,6 +75,12 @@ deploy {
         roborio.artifacts {
             register<FRCJavaArtifact>("frcJava") {
                 jvmArgs.add("-ea") // Remove this flag during comp to disable asserts
+//                jvmArgs.add("-Dcom.sun.management.jmxremote=true")
+//                jvmArgs.add("-Dcom.sun.management.jmxremote.port=1198")
+//                jvmArgs.add("-Dcom.sun.management.jmxremote.local.only=false")
+//                jvmArgs.add("-Dcom.sun.management.jmxremote.ssl=false")
+//                jvmArgs.add("-Dcom.sun.management.jmxremote.authenticate=false")
+//                jvmArgs.add("-Djava.rmi.server.hostname=10.36.36.2") // Replace TE.AM with team number
                 setJarTask(tasks.jar)
                 dependsOn(tasks.assemble)
             }
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/CAN.kt b/src/main/kotlin/com/frcteam3636/frc2024/CAN.kt
index 95ff0f3..70f2a6b 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/CAN.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/CAN.kt
@@ -19,9 +19,8 @@ enum class REVMotorControllerId(val num: Int) {
     BackRightDrivingMotor(3),
     FrontRightDrivingMotor(4),
 
+    IntakeMotor(12),
     IndexerMotor(13),
-
-    IntakeMotor(21),
 }
 
 fun CANSparkMax(id: REVMotorControllerId, type: CANSparkLowLevel.MotorType) =
@@ -35,8 +34,8 @@ enum class CTREDeviceId(val num: Int, val bus: String) {
     BackLeftDrivingMotor(2, "*"),
     BackRightDrivingMotor(3, "*"),
     FrontRightDrivingMotor(4, "*"),
-    RightArmMotor(10, "*"),
-    LeftArmMotor(11, "*"),
+    RightArmMotor(11, "*"),
+    LeftArmMotor(10, "*"),
     PigeonGyro(20, "*"),
 }
 
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/Dashboard.kt b/src/main/kotlin/com/frcteam3636/frc2024/Dashboard.kt
index 7cb62d0..2927aa4 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/Dashboard.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/Dashboard.kt
@@ -71,12 +71,9 @@ object Dashboard {
             .withSize(6, 2)
             .withPosition(0, 2)
 
-        tab.addBoolean("NavX OK") { Diagnostics.latest.navXConnected }
+        tab.addBoolean("Gyro OK") { Diagnostics.latest.gyroConnected }
             .withPosition(10, 0)
             .withSize(2, 1)
-        tab.addBoolean("Cameras OK") { Diagnostics.latest.navXConnected }
-            .withPosition(10, 1)
-            .withSize(2, 1)
         tab.addBoolean("CAN Bus OK") { Diagnostics.latest.canStatus.transmitErrorCount == 0 && Diagnostics.latest.canStatus.receiveErrorCount == 0 }
             .withPosition(10, 2)
             .withSize(2, 1)
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/Diagnostics.kt b/src/main/kotlin/com/frcteam3636/frc2024/Diagnostics.kt
index 7864a89..68455f5 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/Diagnostics.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/Diagnostics.kt
@@ -17,8 +17,7 @@ import edu.wpi.first.wpilibj.RobotController
  */
 data class Diagnostics(
     val batteryFull: Boolean,
-    val navXConnected: Boolean,
-    val camerasConnected: Boolean,
+    val gyroConnected: Boolean,
     val errorStatusCodes: Map<String, StatusCode>,
     val canStatus: CANStatus,
 ) {
@@ -29,8 +28,7 @@ data class Diagnostics(
         val messages = mutableListOf<ElasticNotification>()
 
         // Add alerts for each suspicious diagnostic condition
-        if (!navXConnected) messages.add(ElasticNotification("NavX disconnected", "The naxX gyro has disconnected!"))
-        if (!camerasConnected) messages.add(ElasticNotification("Camera disconnected", "A camera has disconnected!"))
+        if (!gyroConnected) messages.add(ElasticNotification("IMU disconnected", "The gyro has disconnected!"))
         if (canStatus.transmitErrorCount > 0 || canStatus.receiveErrorCount > 0) {
             messages.add(ElasticNotification("roboRIO CAN Errors", "CAN bus errors detected!"))
         }
@@ -56,8 +54,7 @@ data class Diagnostics(
         /** The most recent diagnostics. */
         var latest = Diagnostics(
             batteryFull = true,
-            navXConnected = true,
-            camerasConnected = true,
+            gyroConnected = true,
             errorStatusCodes = emptyMap(),
             canStatus = CANStatus(),
         )
@@ -73,8 +70,7 @@ data class Diagnostics(
 
             return Diagnostics(
                 batteryFull = RobotController.getBatteryVoltage() >= FULL_BATTERY_VOLTAGE,
-                navXConnected = Drivetrain.inputs.gyroConnected,
-                camerasConnected = Drivetrain.allCamerasConnected,
+                gyroConnected = Drivetrain.inputs.gyroConnected,
                 errorStatusCodes = errorCodes,
                 canStatus = RobotController.getCANStatus(),
             )
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/Robot.kt b/src/main/kotlin/com/frcteam3636/frc2024/Robot.kt
index e955cae..c659baa 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/Robot.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/Robot.kt
@@ -1,6 +1,5 @@
 package com.frcteam3636.frc2024
 
-import com.ctre.phoenix6.SignalLogger
 import com.ctre.phoenix6.StatusSignal
 import com.frcteam3636.frc2024.subsystems.arm.Arm
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain
@@ -13,6 +12,9 @@ import com.frcteam3636.version.BUILD_DATE
 import com.frcteam3636.version.DIRTY
 import com.frcteam3636.version.GIT_BRANCH
 import com.frcteam3636.version.GIT_SHA
+import edu.wpi.first.cameraserver.CameraServer
+import edu.wpi.first.cameraserver.CameraServerSharedStore
+import edu.wpi.first.cscore.UsbCamera
 import edu.wpi.first.hal.FRCNetComm.tInstances
 import edu.wpi.first.hal.FRCNetComm.tResourceType
 import edu.wpi.first.hal.HAL
@@ -24,14 +26,12 @@ import edu.wpi.first.wpilibj2.command.CommandScheduler
 import edu.wpi.first.wpilibj2.command.Commands
 import edu.wpi.first.wpilibj2.command.button.CommandXboxController
 import edu.wpi.first.wpilibj2.command.button.JoystickButton
-import edu.wpi.first.wpilibj2.command.sysid.SysIdRoutine
 import org.littletonrobotics.junction.LogFileUtil
 import org.littletonrobotics.junction.Logger
 import org.littletonrobotics.junction.PatchedLoggedRobot
 import org.littletonrobotics.junction.networktables.NT4Publisher
 import org.littletonrobotics.junction.wpilog.WPILOGReader
 import org.littletonrobotics.junction.wpilog.WPILOGWriter
-import java.io.File
 import kotlin.io.path.Path
 import kotlin.io.path.exists
 
@@ -67,7 +67,7 @@ object Robot : PatchedLoggedRobot() {
         )
 
         // Joysticks are likely to be missing in simulation, which usually isn't a problem.
-        DriverStation.silenceJoystickConnectionWarning(!isReal())
+        DriverStation.silenceJoystickConnectionWarning(RobotBase.isSimulation())
 
         configureAdvantageKit()
         configureSubsystems()
@@ -75,10 +75,8 @@ object Robot : PatchedLoggedRobot() {
         configureBindings()
         configureDashboard()
 
-        Intake.register()
-
-        //configure bindings
-        configureBindings()
+        val camera = CameraServer.startAutomaticCapture()
+        camera.setResolution(160, 160)
     }
 
     /** Start logging or pull replay logs from a file */
@@ -90,21 +88,24 @@ object Robot : PatchedLoggedRobot() {
         Logger.recordMetadata("Model", model.name)
 
         if (isReal()) {
-            Logger.addDataReceiver(WPILOGWriter()) // Log to a USB stick
-            if (!Path("/U").exists()) {
-                Elastic.sendAlert(
-                    ElasticNotification(
-                        "logging USB stick not plugged into radio",
-                        "You gotta plug in a usb stick yo",
-                        NotificationLevel.WARNING
-                    )
-                )
-            }
+            // This competition we aren't using a USB log stick because there's no extra USB port on the RoboRIO.
+//            Logger.addDataReceiver(WPILOGWriter()) // Log to a USB stick
+//            if (!Path("/U").exists()) {
+//                Elastic.sendAlert(
+//                    ElasticNotification(
+//                        "Insert Log USB drive into RoboRIO",
+//                        "This match will not have debug logs.",
+//                        NotificationLevel.WARNING
+//                    )
+//                )
+//            }
+            Logger.addDataReceiver(WPILOGWriter("/home/lvuser/logs")) // Log on-device instead
+
             Logger.addDataReceiver(NT4Publisher()) // Publish data to NetworkTables
             // Enables power distribution logging
             if (model == Model.COMPETITION) {
                 PowerDistribution(
-                    1, PowerDistribution.ModuleType.kRev
+                    62, PowerDistribution.ModuleType.kRev
                 )
             } else {
                 PowerDistribution(
@@ -155,7 +156,7 @@ object Robot : PatchedLoggedRobot() {
 
     /** Configure which commands each joystick button triggers. */
     private fun configureBindings() {
-        Drivetrain.defaultCommand = Drivetrain.driveWithJoysticks(joystickLeft, joystickRight)
+         Drivetrain.defaultCommand = Drivetrain.driveWithJoysticks(joystickLeft, joystickRight)
         Indexer.defaultCommand = Indexer.autoRun()
 
         // (The button with the yellow tape on it)
@@ -164,73 +165,44 @@ object Robot : PatchedLoggedRobot() {
             Drivetrain.zeroGyro()
         }).ignoringDisable(true))
 
-//        //Intake
-//        controller.a()
-//            .debounce(0.150)
-//            .whileTrue(
-//                Intake.outtake()
-//            )
-//
-//        controller.x()
-//            .debounce(0.150)
-//            .whileTrue(
-//                Intake.intake()
-//            )
-//
-//        controller.b()
-//            .debounce(0.150)
-//            .whileTrue(
-//                Indexer.outtakeBalloon()
-//            )
-//
-//        controller.y()
-//            .debounce(0.150)
-//            .whileTrue(
-//                Indexer.indexBalloon()
-//            )
-
-//        //Outtake
-//        controller.leftBumper()
-//            .whileTrue(
-//                Commands.parallel(
-//                    Intake.outtake(),
-//                )
-//            )
-
-        //SysId
+        // Intake
         controller.leftBumper()
-            .onTrue(Commands.runOnce(SignalLogger::start))
+            .whileTrue(Intake.intake())
 
         controller.rightBumper()
-            .onTrue(Commands.runOnce(SignalLogger::stop))
+            .whileTrue(Intake.intake())
+
+        controller.rightTrigger().whileTrue(Indexer.indexBalloon())
+        controller.leftTrigger().whileTrue(Indexer.outtakeBalloon())
+
+
 
+
+//        Arm positions
         controller.y()
-            .whileTrue(Arm.sysIdQuasistatic(SysIdRoutine.Direction.kForward))
+            .onTrue(
+                Arm.moveToPosition(Arm.Position.Stowed)
+            )
+
+        controller.x()
+            .onTrue(
+                Arm.moveToPosition(Arm.Position.PickUp)
+            )
+
 
         controller.a()
-            .whileTrue(Arm.sysIdQuasistatic(SysIdRoutine.Direction.kReverse))
+            .onTrue(
+                Arm.moveToPosition(Arm.Position.Lower))
+
 
         controller.b()
-            .whileTrue(Arm.sysIdDynamic(SysIdRoutine.Direction.kForward))
+            .whileTrue(Arm.coastMode().ignoringDisable(true))
 
-        controller.x()
-            .whileTrue(Arm.sysIdDynamic(SysIdRoutine.Direction.kReverse))
+        controller.button(7)
+            .and(controller.button(8))
+            .and(controller.y())
+            .onTrue(Arm.zeroIt().ignoringDisable(true))
 
-        //Arm positions
-//        controller.a()
-//            .onTrue(
-//                Arm.moveToPosition(Arm.Position.Stowed)
-//            )
-//
-//        controller.x()
-//            .onTrue(
-//                Arm.moveToPosition(Arm.Position.PickUp)
-//            )
-//
-//        controller.y()
-//            .onTrue(
-//                Arm.moveToPosition(Arm.Position.Lower)
-//            )
     }
 
     /** Add data to the driver station dashboard. */
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/Arm.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/Arm.kt
index 1b8538f..790f6b5 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/Arm.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/Arm.kt
@@ -2,28 +2,29 @@ package com.frcteam3636.frc2024.subsystems.arm
 
 import com.ctre.phoenix6.SignalLogger
 import com.frcteam3636.frc2024.Robot
-import com.frcteam3636.frc2024.subsystems.intake.Intake
-import com.frcteam3636.frc2024.subsystems.intake.Intake.indexerAngleLigament
-import com.frcteam3636.frc2024.subsystems.intake.Intake.intakeAngleLigament
+import com.frcteam3636.frc2024.utils.math.TAU
 import edu.wpi.first.units.Angle
 import edu.wpi.first.units.Measure
-import edu.wpi.first.units.Units.Degrees
-import edu.wpi.first.units.Units.Volts
+import edu.wpi.first.units.Time
+import edu.wpi.first.units.Units.*
+import edu.wpi.first.wpilibj.DriverStation
 import edu.wpi.first.wpilibj.Timer
 import edu.wpi.first.wpilibj.smartdashboard.Mechanism2d
 import edu.wpi.first.wpilibj.smartdashboard.MechanismLigament2d
 import edu.wpi.first.wpilibj.util.Color
 import edu.wpi.first.wpilibj.util.Color8Bit
+import edu.wpi.first.wpilibj2.command.Command
+import edu.wpi.first.wpilibj2.command.StartEndCommand
 import edu.wpi.first.wpilibj2.command.Subsystem
 import edu.wpi.first.wpilibj2.command.sysid.SysIdRoutine
 import edu.wpi.first.wpilibj2.command.sysid.SysIdRoutine.Direction
 import edu.wpi.first.wpilibj2.command.sysid.SysIdRoutine.Mechanism
 import org.littletonrobotics.junction.Logger
-import kotlin.math.cos
 import kotlin.math.sin
+import kotlin.time.Duration
 
 
-private const val SECONDS_BETWEEN_ARM_UPDATES = 0.5
+private const val SECONDS_BETWEEN_ARM_UPDATES = 1.0
 
 object Arm : Subsystem {
     private var io: ArmIO = when (Robot.model) {
@@ -60,22 +61,63 @@ object Arm : Subsystem {
     override fun periodic() {
         io.updateInputs(inputs)
         Logger.processInputs("/Arm", inputs)
-        armAngleLigament.angle = inputs.position.`in`(Degrees)
-        armWristAngleLigament.angle = 90.0 - inputs.position.`in`(Degrees)
+        armAngleLigament.angle = inputs.leftPosition.`in`(Degrees)
+        armWristAngleLigament.angle = 90.0 - inputs.leftPosition.`in`(Degrees)
 
-        if (timer.advanceIfElapsed(SECONDS_BETWEEN_ARM_UPDATES) && inputs.absoluteEncoderConnected){
-                io.updatePosition(inputs.absoluteEncoderPosition)
+        if (timer.advanceIfElapsed(SECONDS_BETWEEN_ARM_UPDATES)
+            && inputs.leftAbsoluteEncoderConnected
+            && inputs.rightAbsoluteEncoderConnected) {
+            io.updatePosition(left = inputs.leftPosition, right = inputs.rightPosition)
         }
-        Logger.recordOutput("/Arm/Mechanism", mechanism)
 
+        Logger.recordOutput("/Arm/Mechanism", mechanism)
+        Logger.recordOutput("/Arm/IsZeroed", io.armZeroed)
     }
 
     fun moveToPosition(position: Position) =
         startEnd({
             io.pivotToPosition(position.angle)
         }, {
-            io.pivotToPosition(inputs.position)
+            io.pivotToPosition(inputs.leftPosition)
+        })!!
+
+    fun coastMode() =
+        startEnd({
+            io.setCoastMode(true)
+        }, {
+            io.setCoastMode(false)
+        })!!
+
+    /**
+     * Follow a sine wave to test the arm's motion control.
+     *
+     * The wave begins as soon as the command is instantiated, not when the command is scheduled.
+     *
+     * @param center the angle which the wave oscillates around
+     * @param magnitude the size of the wave
+     * @param period the time before the wave returns to its original position
+     */
+    fun followWave(center: Measure<Angle>, magnitude: Measure<Angle>, period: Measure<Time> = Seconds.of(5.0)): Command {
+        val timer = Timer().apply {
+            start()
+        }
+        return runEnd({
+            // Use the formula for a sine wave with a magnitude, period, and center point.
+            val setpoint = magnitude * sin(timer.get() * TAU / period.`in`(Seconds)) + center
+            io.pivotToPosition(setpoint)
+        }, {
+            io.pivotToPosition(inputs.leftPosition)
         })!!
+    }
+
+    fun zeroIt() = runOnce {
+        if (DriverStation.isDisabled()) {
+            io.zeroHere(inputs)
+            print("*************** Arm Zeroed !! ***************")
+        } else {
+            print("Disable the robot to zero the arm!")
+        }
+    }
 
     fun sysIdQuasistatic(direction: Direction) =
         sysID.quasistatic(direction)!!
@@ -84,8 +126,12 @@ object Arm : Subsystem {
         sysID.dynamic(direction)!!
 
     enum class Position(val angle: Measure<Angle>) {
-        Stowed(Degrees.of(135.0)),
-        PickUp(Degrees.of(30.0)),
-        Lower(Degrees.of(-15.0))
+        /** All the way up */
+        Stowed(Degrees.of(-127.0)),
+//        Stowed(Degrees.of(-80.0)),
+        /** Slightly picked up */
+        PickUp(Degrees.of(0.0)),
+        /** Ready to pick up */
+        Lower(Degrees.of(6.0))
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/ArmIO.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/ArmIO.kt
index 83f5d96..3a215a8 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/ArmIO.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/arm/ArmIO.kt
@@ -1,4 +1,5 @@
 package com.frcteam3636.frc2024.subsystems.arm
+import com.ctre.phoenix6.configs.MotorOutputConfigs
 import com.ctre.phoenix6.configs.TalonFXConfiguration
 import com.ctre.phoenix6.controls.MotionMagicTorqueCurrentFOC
 import com.ctre.phoenix6.controls.VoltageOut
@@ -8,6 +9,8 @@ import com.ctre.phoenix6.signals.NeutralModeValue
 import com.frcteam3636.frc2024.CTREDeviceId
 import com.frcteam3636.frc2024.Robot
 import com.frcteam3636.frc2024.TalonFX
+import com.frcteam3636.frc2024.utils.Elastic
+import com.frcteam3636.frc2024.utils.ElasticNotification
 import com.frcteam3636.frc2024.utils.math.*
 import edu.wpi.first.math.system.plant.DCMotor
 import edu.wpi.first.units.Angle
@@ -16,19 +19,19 @@ import edu.wpi.first.units.Units.*
 import edu.wpi.first.units.Voltage
 import edu.wpi.first.wpilibj.DigitalInput
 import edu.wpi.first.wpilibj.DutyCycleEncoder
+import edu.wpi.first.wpilibj.Preferences
 import edu.wpi.first.wpilibj.simulation.SingleJointedArmSim
-import org.littletonrobotics.junction.LogTable
 import org.littletonrobotics.junction.Logger
-import org.littletonrobotics.junction.inputs.LoggableInputs
 import org.team9432.annotation.Logged
 
 @Logged
 open class ArmInputs {
-    var rightPosition = Radians.zero()!!
-    var leftPosition = Radians.zero()!!
-    var position = Radians.zero()!!
+    var reference = Radians.zero()!!
 
-    var absoluteEncoderPosition = Radians.zero()!!
+    var rightRelativePosition = Radians.zero()!!
+    var leftRelativePosition = Radians.zero()!!
+    var leftPosition = Radians.zero()!!
+    var rightPosition = Radians.zero()!!
 
     var rightCurrent = Volts.zero()!!
     var leftCurrent = Volts.zero()!!
@@ -36,10 +39,11 @@ open class ArmInputs {
     var rightVelocity = RadiansPerSecond.zero()!!
     var leftVelocity = RadiansPerSecond.zero()!!
 
-    var absoluteEncoderConnected = false
+    var leftAbsoluteEncoderConnected = false
+    var rightAbsoluteEncoderConnected = false
 }
 
-interface ArmIO{
+interface ArmIO {
 
         fun updateInputs(inputs: ArmInputs)
 
@@ -47,158 +51,261 @@ interface ArmIO{
 
         fun setVoltage(volts: Measure<Voltage>)
 
-        fun updatePosition(position: Measure<Angle>)
-    }
+        fun updatePosition(left: Measure<Angle>, right: Measure<Angle>)
 
+        fun setCoastMode(enabled: Boolean)
 
-    class ArmIOReal: ArmIO{
+        fun zeroHere(inputs: ArmInputs)
 
-        private val leftMotor = TalonFX(CTREDeviceId.LeftArmMotor)
-
-        private val rightMotor = TalonFX(CTREDeviceId.RightArmMotor)
+        val armZeroed: Boolean
+            get() = true
+}
 
-        private val absoluteEncoder = DutyCycleEncoder(DigitalInput(8))
 
-        override fun updateInputs(inputs: ArmInputs) {
-            inputs.position = Rotations.of(absoluteEncoder.absolutePosition)
-            inputs.absoluteEncoderConnected = absoluteEncoder.isConnected
+class ArmIOReal: ArmIO {
+    private val leftMotor = TalonFX(CTREDeviceId.LeftArmMotor)
+    private val rightMotor = TalonFX(CTREDeviceId.RightArmMotor)
 
-            inputs.absoluteEncoderPosition = Rotations.of(absoluteEncoder.absolutePosition)
+    private val leftAbsoluteEncoder = DutyCycleEncoder(DigitalInput(0))
+    private val rightAbsoluteEncoder = DutyCycleEncoder(DigitalInput(1))
 
-            inputs.leftPosition = Rotations.of(leftMotor.position.value)
-            inputs.leftVelocity = RotationsPerSecond.of(leftMotor.velocity.value)
+    private var leftZero: Measure<Angle>
+    private var rightZero: Measure<Angle>
 
+    override var armZeroed = true
+        private set
 
-            inputs.rightPosition = Rotations.of(rightMotor.position.value)
-            inputs.rightVelocity = RotationsPerSecond.of(rightMotor.position.value)
+    private val leftConfig = TalonFXConfiguration().apply {
+        Slot0.apply {
+            pidGains = LEFT_PID_GAINS
+            motorFFGains = LEFT_FF_GAINS
+            GravityType = GravityTypeValue.Arm_Cosine
+            kG = LEFT_GRAVITY_GAIN
+        }
 
-            inputs.rightCurrent = Volts.of(leftMotor.motorVoltage.value)
+        MotorOutput.apply {
+            NeutralMode = NeutralModeValue.Brake
+            Inverted = InvertedValue.CounterClockwise_Positive
+        }
 
-            leftMotor.setPosition(inputs.absoluteEncoderPosition.`in`(Rotations))
-            rightMotor.setPosition(inputs.absoluteEncoderPosition.`in`(Rotations))
+        Feedback.apply {
+            SensorToMechanismRatio = GEAR_RATIO
+            FeedbackRotorOffset = 0.0
         }
 
-        override fun updatePosition(position: Measure<Angle>) {
-            leftMotor.setPosition(position.`in`(Rotations))
-            rightMotor.setPosition(position.`in`(Rotations))
+        MotionMagic.apply {
+            MotionMagicCruiseVelocity = PROFILE_VELOCITY
+            MotionMagicAcceleration = PROFILE_ACCELERATION
+            MotionMagicJerk = PROFILE_JERK
         }
 
-        override fun pivotToPosition(position: Measure<Angle>) {
-            Logger.recordOutput("Shooter/Pivot/Position Setpoint", position)
+        ClosedLoopGeneral.apply {
+            ContinuousWrap = true
+        }
+    }
 
-            val control = MotionMagicTorqueCurrentFOC(0.0).apply {
-                Slot = 0
-                Position = position.`in`(Rotations)
-            }
-            leftMotor.setControl(control)
-            rightMotor.setControl(control)
+    private val rightConfig = TalonFXConfiguration().apply {
+        deserialize(leftConfig.serialize()) // TalonFXConfiguration doesn't implement Cloneable, so we do this instead
 
+        MotorOutput.apply {
+            Inverted = InvertedValue.Clockwise_Positive
         }
 
-        override fun setVoltage(volts: Measure<Voltage>) {
-            assert(volts in Volts.of(-12.0)..Volts.of(12.0))
-            val control = VoltageOut(volts.`in`(Volts))
-            leftMotor.setControl(control)
-            rightMotor.setControl(control)
+        Slot0.apply {
+            pidGains = RIGHT_PID_GAINS
+            motorFFGains = RIGHT_FF_GAINS
+            GravityType = GravityTypeValue.Arm_Cosine
+            kG = RIGHT_GRAVITY_GAIN
         }
+    }
 
-        init {
-            val config = TalonFXConfiguration().apply {
-                MotorOutput.apply {
-                    NeutralMode = NeutralModeValue.Brake
-                }
-
-                Feedback.apply {
-                    SensorToMechanismRatio = GEAR_RATIO
-                    FeedbackRotorOffset = 0.0
-                }
-
-                Slot0.apply {
-                    pidGains = PID_GAINS
-                    motorFFGains = FF_GAINS
-                    GravityType = GravityTypeValue.Arm_Cosine
-                    kG = GRAVITY_GAIN
-                }
-
-                MotionMagic.apply {
-                    MotionMagicCruiseVelocity = PROFILE_VELOCITY
-                    MotionMagicAcceleration = PROFILE_ACCELERATION
-                    MotionMagicJerk = PROFILE_JERK
-                }
-            }
+    private fun warnArmNotZeroed() {
+        Elastic.sendAlert(ElasticNotification("ARM MUST BE ZEROED!!!",
+            "The arm will not work unless it is zeroed before the current match."))
+    }
 
-            config.MotorOutput.Inverted = InvertedValue.CounterClockwise_Positive
-            leftMotor.configurator.apply(
-                config
-            )
+    init {
+        Logger.recordOutput("/Arm/CoastMode", false)
 
-            config.MotorOutput.Inverted = InvertedValue.Clockwise_Positive
-            rightMotor.configurator.apply(config)
+        leftMotor.configurator.apply(leftConfig)
+        rightMotor.configurator.apply(rightConfig)
+
+        if (!Preferences.containsKey("LeftArmZero") || !Preferences.containsKey("RightArmZero")) {
+            warnArmNotZeroed()
+            armZeroed = false
         }
+        leftZero = Radians.of(Preferences.getDouble("LeftArmZero", 0.0))
+        rightZero = Radians.of(Preferences.getDouble("RightArmZero", 0.0))
+    }
 
+    override fun updateInputs(inputs: ArmInputs) {
+        val offsetlessLeftPosition = Rotations.of(-leftAbsoluteEncoder.get() * CHAIN_GEAR_RATIO)
+        inputs.leftPosition = offsetlessLeftPosition + leftZero
+        Logger.recordOutput("/Arm/Required Left Offset", offsetlessLeftPosition.negate())
 
-        internal companion object Constants {
-            private const val GEAR_RATIO = 0.0
-            val PID_GAINS = PIDGains(120.0, 0.0, 100.0) //placeholders
-            val FF_GAINS = MotorFFGains(7.8, 0.0, 0.0) //placeholders
-            private const val GRAVITY_GAIN = 0.0
-            private const val PROFILE_ACCELERATION = 0.0
-            private const val PROFILE_JERK = 0.0
-            private const val PROFILE_VELOCITY = 0.0
+        val offsetlessRightPosition = Rotations.of(rightAbsoluteEncoder.get() * CHAIN_GEAR_RATIO)
+        inputs.rightPosition = offsetlessRightPosition + rightZero
+        Logger.recordOutput("/Arm/Required Right Offset", offsetlessRightPosition.negate())
+
+        inputs.leftRelativePosition = Rotations.of(leftMotor.position.value)
+        inputs.rightRelativePosition = Rotations.of(rightMotor.position.value)
+
+        inputs.leftAbsoluteEncoderConnected = leftAbsoluteEncoder.isConnected
+        inputs.rightAbsoluteEncoderConnected = rightAbsoluteEncoder.isConnected
+
+        inputs.leftVelocity = RotationsPerSecond.of(leftMotor.velocity.value)
+        inputs.rightVelocity = RotationsPerSecond.of(rightMotor.velocity.value)
+
+        inputs.leftCurrent = Volts.of(leftMotor.motorVoltage.value)
+        inputs.rightCurrent = Volts.of(rightMotor.motorVoltage.value)
+
+        inputs.reference = Rotations.of(leftMotor.closedLoopReference.value)
+    }
+
+    override fun updatePosition(left: Measure<Angle>, right: Measure<Angle>) {
+        leftMotor.setPosition(left.`in`(Rotations))
+        rightMotor.setPosition(right.`in`(Rotations))
+    }
+
+    private val pivotControl = MotionMagicTorqueCurrentFOC(0.0)
+    override fun pivotToPosition(position: Measure<Angle>) {
+        if (!armZeroed) return warnArmNotZeroed()
+        Logger.recordOutput("Arm/Position Setpoint", position)
+
+        val control = pivotControl.apply {
+            Slot = 0
+            Position = position.`in`(Rotations)
+        }
+        leftMotor.setControl(control)
+        rightMotor.setControl(control)
+    }
+
+    override fun setCoastMode(enabled: Boolean) {
+        Logger.recordOutput("/Arm/CoastMode", enabled)
+        val neutralModeValue = if (enabled) {
+            NeutralModeValue.Coast
+        } else {
+            NeutralModeValue.Brake
         }
 
+        leftMotor.configurator.apply(leftConfig.apply {
+            MotorOutput.apply {
+                NeutralMode = neutralModeValue
+            }
+        })
+        rightMotor.configurator.apply(rightConfig.apply {
+            MotorOutput.apply {
+                NeutralMode = neutralModeValue
+            }
+        })
+    }
+
+    override fun zeroHere(inputs: ArmInputs) {
+        armZeroed = true
+        leftZero = (inputs.leftPosition - leftZero).negate()
+        rightZero = (inputs.rightPosition - rightZero).negate()
+        Preferences.setDouble("LeftArmZero", leftZero.`in`(Radians))
+        Preferences.setDouble("RightArmZero", rightZero.`in`(Radians))
     }
 
-    class ArmIOSim : ArmIO {
-        val armSim = SingleJointedArmSim(
-            DCMotor.getKrakenX60(1),
-            3.0,
-            0.244,
-            0.331414,
-            -0.142921,
-            2.32814365359,
-            true,
-            -0.142921
-        )
+    override fun setVoltage(volts: Measure<Voltage>) {
+        assert(volts in Volts.of(-12.0)..Volts.of(12.0))
+        if (!armZeroed) return warnArmNotZeroed()
+        Logger.recordOutput("/Arm/Voltage", volts)
+        val control = VoltageOut(volts.`in`(Volts))
+//        leftMotor.setControl(control)
+//        rightMotor.setControl(control)
+    }
 
-        // TODO: Once we know the PID gains, this should be added back.
-//        val pidController = PIDController(ArmIOReal.PID_GAINS)
-        var setPoint = 0.0
+    internal companion object Constants {
+//        private const val GEAR_RATIO = 125.0
+//        val PID_GAINS = PIDGains(60.88, 0.0, 0.40035) //placeholders
+//        val FF_GAINS = MotorFFGains(0.1448, 0.11929, 0.001579) //placeholders
+//        private const val GRAVITY_GAIN = 0.0095692
+//        private const val PROFILE_ACCELERATION = 1.0
+//        private const val PROFILE_JERK = 1.0
+//        private const val PROFILE_VELOCITY = 1.0
+
+        private const val CHAIN_GEAR_RATIO = 1.0 / 3.0
+        private const val GEAR_RATIO = 125.0 / CHAIN_GEAR_RATIO
+        val LEFT_PID_GAINS = PIDGains(54.138, 0.0, 169.411)
+        val LEFT_FF_GAINS = MotorFFGains(0.3289, 42.817, 0.39107)
+        private const val LEFT_GRAVITY_GAIN = 0.17119
+        val RIGHT_PID_GAINS = PIDGains(53.339, 0.0, 169.134)
+        val RIGHT_FF_GAINS = MotorFFGains(0.29364, 43.77, 0.34751)
+        private const val RIGHT_GRAVITY_GAIN = 0.12181
+        private const val PROFILE_ACCELERATION = 1.0
+        private const val PROFILE_JERK = 1.0
+        private const val PROFILE_VELOCITY = 1.0
+    }
 
-        override fun updateInputs(inputs: ArmInputs) {
-            armSim.update(Robot.period)
-            inputs.rightVelocity = RadiansPerSecond.of(armSim.velocityRadPerSec)
-            inputs.leftVelocity = RadiansPerSecond.of(armSim.velocityRadPerSec)
-            inputs.position = Radians.of(armSim.angleRads)
+}
+
+class ArmIOSim : ArmIO {
+    val armSim = SingleJointedArmSim(
+        DCMotor.getKrakenX60(1),
+        3.0,
+        0.244,
+        0.331414,
+        -0.142921,
+        2.32814365359,
+        true,
+        -0.142921
+    )
+
+    // TODO: Once we know the PID gains, this should be added back.
+//        val pidController = PIDController(ArmIOReal.PID_GAINS)
+    var setPoint = 0.0
+
+    override fun updateInputs(inputs: ArmInputs) {
+        armSim.update(Robot.period)
+        inputs.rightVelocity = RadiansPerSecond.of(armSim.velocityRadPerSec)
+        inputs.leftVelocity = RadiansPerSecond.of(armSim.velocityRadPerSec)
+        inputs.leftPosition = Radians.of(armSim.angleRads)
+        inputs.rightPosition = Radians.of(armSim.angleRads)
 //            val pidVoltage = pidController.calculate(inputs.position.`in`(Radians),setPoint)
 //            armSim.setInputVoltage(pidVoltage)
-        }
+    }
 
-        override fun pivotToPosition(position: Measure<Angle>) {
-            setPoint = position.`in`(Radians)
-        }
+    override fun pivotToPosition(position: Measure<Angle>) {
+        setPoint = position.`in`(Radians)
+    }
 
-        override fun setVoltage(volts: Measure<Voltage>) {
-            armSim.setInputVoltage(volts.`in`(Volts))
-            Logger.recordOutput("/Arm/OutVolt", volts)
-        }
+    override fun setVoltage(volts: Measure<Voltage>) {
+        armSim.setInputVoltage(volts.`in`(Volts))
+        Logger.recordOutput("/Arm/OutVolt", volts)
+    }
 
-        override fun updatePosition(position: Measure<Angle>) {
-            // no drifting in sim so no need to update
-        }
+    override fun updatePosition(left: Measure<Angle>, right: Measure<Angle>) {
+        // no drifting in sim so no need to update
     }
 
-    class ArmIOPrototype: ArmIO {
-        //placeholder
-        override fun updateInputs(inputs: ArmInputs) {
-        }
+    override fun setCoastMode(enabled: Boolean) {
 
-        override fun pivotToPosition(position: Measure<Angle>) {
-        }
+    }
 
-        override fun setVoltage(volts: Measure<Voltage>) {
-        }
+    override fun zeroHere(inputs: ArmInputs) {
+    }
+}
 
-        override fun updatePosition(position: Measure<Angle>) {
-        }
+class ArmIOPrototype: ArmIO {
+    //placeholder
+    override fun updateInputs(inputs: ArmInputs) {
+    }
+
+    override fun pivotToPosition(position: Measure<Angle>) {
+    }
+
+    override fun setVoltage(volts: Measure<Voltage>) {
     }
+
+    override fun updatePosition(left: Measure<Angle>, right: Measure<Angle>) {
+    }
+
+    override fun setCoastMode(enabled: Boolean) {
+
+    }
+
+    override fun zeroHere(inputs: ArmInputs) {
+    }
+}
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Drivetrain.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Drivetrain.kt
index 19e5978..901e0b2 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Drivetrain.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Drivetrain.kt
@@ -7,6 +7,7 @@ import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.BRAKE_
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.DEFAULT_PATHING_CONSTRAINTS
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.FREE_SPEED
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.JOYSTICK_DEADBAND
+import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.JOYSTICK_EXPONENT
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.ROTATION_SENSITIVITY
 import com.frcteam3636.frc2024.subsystems.drivetrain.Drivetrain.Constants.TRANSLATION_SENSITIVITY
 import com.frcteam3636.frc2024.utils.ElasticWidgets
@@ -43,6 +44,7 @@ import java.util.*
 import kotlin.jvm.optionals.getOrNull
 import kotlin.math.PI
 import kotlin.math.abs
+import kotlin.math.pow
 
 /** A singleton object representing the drivetrain. */
 object Drivetrain : Subsystem, Sendable {
@@ -205,10 +207,16 @@ object Drivetrain : Subsystem, Sendable {
             // No joystick input - stop moving!
             desiredModuleStates = BRAKE_POSITION
         } else {
+            // Prevent even powers from removing negatives by multiplying outside of abs
+            val exponentialTranslation = Translation2d(
+                translationInput.x * abs(translationInput.x.pow(JOYSTICK_EXPONENT - 1)),
+                translationInput.y * abs(translationInput.y.pow(JOYSTICK_EXPONENT - 1)),
+            )
+
             desiredChassisSpeeds = ChassisSpeeds.fromFieldRelativeSpeeds(
-                translationInput.x * FREE_SPEED.baseUnitMagnitude() * TRANSLATION_SENSITIVITY,
-                translationInput.y * FREE_SPEED.baseUnitMagnitude() * TRANSLATION_SENSITIVITY,
-                -rotationInput.y * TAU * ROTATION_SENSITIVITY,
+                exponentialTranslation.x * FREE_SPEED.baseUnitMagnitude() * TRANSLATION_SENSITIVITY,
+                exponentialTranslation.y * FREE_SPEED.baseUnitMagnitude() * TRANSLATION_SENSITIVITY,
+                rotationInput.y * TAU * ROTATION_SENSITIVITY,
                 inputs.gyroRotation.toRotation2d()
             )
         }
@@ -220,6 +228,11 @@ object Drivetrain : Subsystem, Sendable {
             drive(translationJoystick.translation2d, rotationJoystick.translation2d)
         }
 
+    fun driveWithOneJoystick(joystick: Joystick): Command =
+        run {
+            drive(joystick.translation2d, Translation2d(0.0, -joystick.z))
+        }
+
     @Suppress("unused")
     fun driveWithController(controller: CommandXboxController): Command =
         run {
@@ -279,15 +292,16 @@ object Drivetrain : Subsystem, Sendable {
     internal object Constants {
         // Translation/rotation coefficient for teleoperated driver controls
         /** Unit: Percent of max robot speed */
-        const val TRANSLATION_SENSITIVITY = 0.1
+        const val TRANSLATION_SENSITIVITY = 1.0
 
         /** Unit: Rotations per second */
-        const val ROTATION_SENSITIVITY = 0.4
+        const val ROTATION_SENSITIVITY = 0.6
 
         private val WHEEL_BASE: Double = Units.inchesToMeters(30.0)
         private val TRACK_WIDTH: Double = Units.inchesToMeters(28.0)
 
-        const val JOYSTICK_DEADBAND = 0.15
+        const val JOYSTICK_DEADBAND = 0.075
+        const val JOYSTICK_EXPONENT = 2
 
         val MODULE_POSITIONS =
             PerCorner(
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Module.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Module.kt
index b11f8e3..1d0c9f0 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Module.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/drivetrain/Module.kt
@@ -133,15 +133,18 @@ class DrivingTalon(id: CTREDeviceId) : DrivingMotor {
 
     }
 
+    private val positionSignal = inner.position
+    private val velocitySignal = inner.velocity
+
     init {
         Robot.statusSignals[id.name] = inner.version
     }
 
     override val position: Measure<Distance>
-        get() = Meters.of(inner.position.value * DRIVING_GEAR_RATIO_TALON * WHEEL_CIRCUMFERENCE.`in`(Meters))
+        get() = Meters.of(positionSignal.value * DRIVING_GEAR_RATIO_TALON * WHEEL_CIRCUMFERENCE.`in`(Meters))
 
     override var velocity: Measure<Velocity<Distance>>
-        get() = MetersPerSecond.of(inner.velocity.value * DRIVING_GEAR_RATIO_TALON * WHEEL_CIRCUMFERENCE.`in`(Meters))
+        get() = MetersPerSecond.of(velocitySignal.value * DRIVING_GEAR_RATIO_TALON * WHEEL_CIRCUMFERENCE.`in`(Meters))
         set(value) {
             inner.setControl(VelocityTorqueCurrentFOC(value.`in`(MetersPerSecond) / DRIVING_GEAR_RATIO_TALON / WHEEL_CIRCUMFERENCE.`in`(Meters)))
         }
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/Indexer.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/Indexer.kt
index 9ed00d9..b33e39d 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/Indexer.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/Indexer.kt
@@ -4,13 +4,16 @@ import com.frcteam3636.frc2024.Robot
 import com.frcteam3636.frc2024.subsystems.intake.Intake
 import edu.wpi.first.units.Units.Degrees
 import edu.wpi.first.wpilibj.DriverStation
+import edu.wpi.first.wpilibj.Timer
 import edu.wpi.first.wpilibj.util.Color
 import edu.wpi.first.wpilibj.util.Color8Bit
 import edu.wpi.first.wpilibj2.command.Command
 import edu.wpi.first.wpilibj2.command.Subsystem
 import org.littletonrobotics.junction.Logger
 
-object Indexer: Subsystem {
+object Indexer : Subsystem {
+    private val INDEXER_SPEED = 1.0
+
     private var io: IndexerIO = when (Robot.model) {
         Robot.Model.SIMULATION -> IndexerIOSim()
         Robot.Model.COMPETITION -> IndexerIOReal()
@@ -36,34 +39,45 @@ object Indexer: Subsystem {
      * Does not run if no balloon.
      * Reverses if balloon is wrong alliance.
      */
-    fun autoRun(): Command =
-        runEnd(
+    fun autoRun(): Command {
+        var previousState = BalloonState.None;
+        var timer = Timer()
+        timer.start()
+        return runEnd(
             {
-                DriverStation.getAlliance().map {
-                    if (
-                        (inputs.balloonState == BalloonState.Blue && it == DriverStation.Alliance.Blue)
-                        || (inputs.balloonState == BalloonState.Red && it == DriverStation.Alliance.Red)
-                    ) {
-                        io.setSpinSpeed(0.5)
-                    } else if (inputs.balloonState == BalloonState.None) {
-                        io.setSpinSpeed(0.0)
-                    } else {
-                        io.setSpinSpeed(-0.5)
+                if (previousState != inputs.balloonState) {
+                    timer.reset()
+                }
+
+                if (timer.hasElapsed(0.5) || inputs.balloonState != BalloonState.None) {
+                    DriverStation.getAlliance().map {
+                        if (
+                            (inputs.balloonState == BalloonState.Blue && it == DriverStation.Alliance.Blue)
+                            || (inputs.balloonState == BalloonState.Red && it == DriverStation.Alliance.Red)
+                            || inputs.balloonState == BalloonState.None
+                        ) {
+                            io.setVoltage(INDEXER_SPEED)
+                        } else {
+                            io.setVoltage(-INDEXER_SPEED)
+                        }
                     }
                 }
+
+                previousState = inputs.balloonState;
             },
             {
-                io.setSpinSpeed(0.0)
+                io.setVoltage(0.0)
             }
         )
+    }
 
     fun indexBalloon(): Command = runEnd(
-        {io.setSpinSpeed(0.5)},
-        {io.setSpinSpeed(0.0)}
+        { io.setVoltage(INDEXER_SPEED) },
+        { io.setVoltage(0.0) }
     )
 
     fun outtakeBalloon(): Command = runEnd(
-        {io.setSpinSpeed(-0.5)},
-        {io.setSpinSpeed(0.0)}
+        { io.setVoltage(-INDEXER_SPEED) },
+        { io.setVoltage(0.0) }
     )
 }
\ No newline at end of file
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/IndexerIO.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/IndexerIO.kt
index 5dda329..c734ca9 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/IndexerIO.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/indexer/IndexerIO.kt
@@ -32,8 +32,8 @@ open class IndexerInputs {
 interface IndexerIO {
     fun updateInputs(inputs: IndexerInputs)
 
-    fun setSpinSpeed(speed: Double)
-    // percent of full speed
+    fun setVoltage(voltage: Double)
+    // percent of full voltage
 }
 
 class IndexerIOReal : IndexerIO{
@@ -49,6 +49,7 @@ class IndexerIOReal : IndexerIO{
             CANSparkLowLevel.MotorType.kBrushless
         )
 
+
     override fun updateInputs(inputs: IndexerInputs) {
         inputs.indexerVelocity = Rotations.per(Minute).of(indexerMotor.encoder.velocity)
         inputs.indexerCurrent = Amps.of(indexerMotor.outputCurrent)
@@ -63,10 +64,10 @@ class IndexerIOReal : IndexerIO{
         }
     }
 
-    override fun setSpinSpeed(speed: Double) {
-        assert(speed in -1.0..1.0)
-        println("Speed: $speed")
-        indexerMotor.set(speed)
+    override fun setVoltage(voltage: Double) {
+        assert(voltage in -12.0..12.0)
+        Logger.recordOutput("/Indexer/OutputVoltage", voltage)
+        indexerMotor.setVoltage(voltage)
     }
 }
 
@@ -84,9 +85,9 @@ class IndexerIOSim: IndexerIO {
         inputs.position = Radians.of(inputs.position.`in`(Radians).mod(TAU))
     }
 
-    override fun setSpinSpeed(speed: Double) {
-        assert(speed in -1.0..1.0)
-        flywheelSim.setInputVoltage(speed*12.0)
+    override fun setVoltage(voltage: Double) {
+        assert(voltage in -1.0..1.0)
+        flywheelSim.setInputVoltage(voltage*12.0)
     }
 }
 
@@ -94,6 +95,6 @@ class IndexerIOPrototype: IndexerIO {
     override fun updateInputs(inputs: IndexerInputs) {
     }
 
-    override fun setSpinSpeed(speed: Double) {
+    override fun setVoltage(voltage: Double) {
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/intake/Intake.kt b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/intake/Intake.kt
index 4ff8b0b..8a08711 100644
--- a/src/main/kotlin/com/frcteam3636/frc2024/subsystems/intake/Intake.kt
+++ b/src/main/kotlin/com/frcteam3636/frc2024/subsystems/intake/Intake.kt
@@ -40,20 +40,10 @@ object Intake: Subsystem {
         Logger.recordOutput("Intake Angle", mechanism)
     }
 
-    fun outtake(): Command =
-        startEnd(
-            {
-                io.setSpeed(-0.5)
-            },
-            {
-                io.setSpeed(0.0)
-            }
-        )
-
     fun intake(): Command =
         startEnd(
             {
-                io.setSpeed(0.7)
+                io.setSpeed(0.1)
             },
             {
                 io.setSpeed(0.0)