Shooter Subsystem

.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sat Feb 07 15:30:15 EST 2026
+gradle.version=8.11

.wpilib/wpilib_preferences.json

@@ -0,0 +1,6 @@
+{
+    "currentLanguage": "none",
+    "enableCppIntellisense": false,
+    "projectYear": "none",
+    "teamNumber": 2706
+}

2026-2706-Robot-Code/simgui-ds.json

@@ -0,0 +1,92 @@
+{
+  "keyboardJoysticks": [
+    {
+      "axisConfig": [
+        {
+          "decKey": 65,
+          "incKey": 68
+        },
+        {
+          "decKey": 87,
+          "incKey": 83
+        },
+        {
+          "decKey": 69,
+          "decayRate": 0.0,
+          "incKey": 82,
+          "keyRate": 0.009999999776482582
+        }
+      ],
+      "axisCount": 3,
+      "buttonCount": 4,
+      "buttonKeys": [
+        90,
+        88,
+        67,
+        86
+      ],
+      "povConfig": [
+        {
+          "key0": 328,
+          "key135": 323,
+          "key180": 322,
+          "key225": 321,
+          "key270": 324,
+          "key315": 327,
+          "key45": 329,
+          "key90": 326
+        }
+      ],
+      "povCount": 1
+    },
+    {
+      "axisConfig": [
+        {
+          "decKey": 74,
+          "incKey": 76
+        },
+        {
+          "decKey": 73,
+          "incKey": 75
+        }
+      ],
+      "axisCount": 2,
+      "buttonCount": 4,
+      "buttonKeys": [
+        77,
+        44,
+        46,
+        47
+      ],
+      "povCount": 0
+    },
+    {
+      "axisConfig": [
+        {
+          "decKey": 263,
+          "incKey": 262
+        },
+        {
+          "decKey": 265,
+          "incKey": 264
+        }
+      ],
+      "axisCount": 2,
+      "buttonCount": 6,
+      "buttonKeys": [
+        260,
+        268,
+        266,
+        261,
+        269,
+        267
+      ],
+      "povCount": 0
+    },
+    {
+      "axisCount": 0,
+      "buttonCount": 0,
+      "povCount": 0
+    }
+  ]
+}

2026-2706-Robot-Code/src/main/java/frc/robot/Constants.java

@@ -14,6 +14,45 @@
  */
 public final class Constants {
   public static class OperatorConstants {
-    public static final int kDriverControllerPort = 0;
+    public static final int kDriverControllerPort = 0;    
+    public static final int kOperatorControllerPort = 1;
   }
+  public static class RobotConstants {
+    public static final int kSelectorSwitchPort = 0;
+  }
+
+  public static final class CANID {
+
+    public static final int SHOOTER1 = 31;
+    public static final int SHOOTER2 = 15;
+    public static final int FEEDER = 40;
+    //public static final int INDEXER = 27;
+
+  }
+
+  public static final class shooterConstants {
+
+    public static final byte MOTOR1_ID = CANID.SHOOTER1;
+    public static final byte MOTOR2_ID = CANID.SHOOTER2;
+    public static final byte FEEDER_MOTOR_ID = CANID.FEEDER;
+    //public static final byte INDEXER_MOTOR_ID = CANID.INDEXER;
+
+    // PID VALUES
+
+    public static final double kP1 = 0,
+                               kI1 = 0,
+                               kD1 = 0,
+                               kFF1 = 0,
+                               kP2 = 0,
+                               kI2 = 0,
+                               kD2 = 0,
+                               kFF2 = 0,
+                               kP3 = 0,
+                               kI3 = 0,
+                               kD3 = 0,
+                               kFF3 = 0;
+  }
+
+
+
 }

2026-2706-Robot-Code/src/main/java/frc/robot/Robot.java

@@ -8,6 +8,7 @@
 import edu.wpi.first.wpilibj2.command.Command;
 import edu.wpi.first.wpilibj2.command.CommandScheduler;
 
+
 /**
  * The methods in this class are called automatically corresponding to each mode, as described in
  * the TimedRobot documentation. If you change the name of this class or the package after creating
@@ -16,6 +17,8 @@
 public class Robot extends TimedRobot {
   private Command m_autonomousCommand;
 
+
+
   private final RobotContainer m_robotContainer;
 
   /**
@@ -25,9 +28,13 @@ public class Robot extends TimedRobot {
   public Robot() {
     // Instantiate our RobotContainer.  This will perform all our button bindings, and put our
     // autonomous chooser on the dashboard.
+    System.out.println("shooter system initialized");
     m_robotContainer = new RobotContainer();
+
+
   }
 
+
   /**
    * This function is called every 20 ms, no matter the mode. Use this for items like diagnostics
    * that you want ran during disabled, autonomous, teleoperated and test.
@@ -79,7 +86,8 @@ public void teleopInit() {
 
   /** This function is called periodically during operator control. */
   @Override
-  public void teleopPeriodic() {}
+  public void teleopPeriodic() {
+  }
 
   @Override
   public void testInit() {

2026-2706-Robot-Code/src/main/java/frc/robot/RobotContainer.java

@@ -5,12 +5,28 @@
 package frc.robot;
 
 import frc.robot.Constants.OperatorConstants;
+
 import frc.robot.commands.Autos;
 import frc.robot.commands.ExampleCommand;
+import edu.wpi.first.wpilibj2.command.PrintCommand;
+
+
 import frc.robot.subsystems.ExampleSubsystem;
+import frc.robot.subsystems.AutoSelectorKnobSubsystem;
+import frc.robot.subsystems.ShooterSubsystem;
+
 import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.Commands;
 import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
 import edu.wpi.first.wpilibj2.command.button.Trigger;
+import frc.robot.commands.startShooter;
+import frc.robot.commands.stopShooter;
+
+
+
+
+
+
 
 /**
  * This class is where the bulk of the robot should be declared. Since Command-based is a
@@ -20,11 +36,16 @@
  */
 public class RobotContainer {
   // The robot's subsystems and commands are defined here...
-  private final ExampleSubsystem m_exampleSubsystem = new ExampleSubsystem();
+  //private final ExampleSubsystem m_exampleSubsystem = new ExampleSubsystem();
+  private final AutoSelectorKnobSubsystem m_AutoSelectorKnobSubsystem = new AutoSelectorKnobSubsystem();
+
+
+  private final CommandXboxController m_operatorController = new CommandXboxController(OperatorConstants.kOperatorControllerPort);
+  private final ShooterSubsystem m_ShooterSubsystem = new ShooterSubsystem();
 
   // Replace with CommandPS4Controller or CommandJoystick if needed
-  private final CommandXboxController m_driverController =
-      new CommandXboxController(OperatorConstants.kDriverControllerPort);
+  // private final CommandXboxController m_driverController =
+  //     new CommandXboxController(OperatorConstants.kDriverControllerPort);
 
   /** The container for the robot. Contains subsystems, OI devices, and commands. */
   public RobotContainer() {
@@ -43,21 +64,62 @@ public RobotContainer() {
    */
   private void configureBindings() {
     // Schedule `ExampleCommand` when `exampleCondition` changes to `true`
-    new Trigger(m_exampleSubsystem::exampleCondition)
-        .onTrue(new ExampleCommand(m_exampleSubsystem));
+    //new Trigger(m_exampleSubsystem::exampleCondition)
+        //.onTrue(new ExampleCommand(m_exampleSubsystem));
 
     // Schedule `exampleMethodCommand` when the Xbox controller's B button is pressed,
     // cancelling on release.
-    m_driverController.b().whileTrue(m_exampleSubsystem.exampleMethodCommand());
+    //m_driverController.b().whileTrue(m_exampleSubsystem.exampleMethodCommand());
+
+    m_operatorController.a().whileTrue(new startShooter(m_ShooterSubsystem)).onFalse(new stopShooter(m_ShooterSubsystem));
+
+
   }
 
-  /**
-   * Use this to pass the autonomous command to the main {@link Robot} class.
-   *
-   * @return the command to run in autonomous
-   */
+
+
+  /** This function returns the autonomous command based on the knob position. */
   public Command getAutonomousCommand() {
-    // An example command will be run in autonomous
-    return Autos.exampleAuto(m_exampleSubsystem);
-  }
-}
+    int mode = m_AutoSelectorKnobSubsystem.getAutoMode();
+    System.out.println("Auto Mode = " + mode); // debug print
+
+    switch (mode) {
+      case 0:
+        return null; // do nothing
+      case 1:
+        return new PrintCommand("1");
+        //DriveDistance(39, 0.3, m_robotDrive);
+      case 2:
+        return new PrintCommand("2");
+        //DriveTimed(2.0, 0.3, m_robotDrive);
+      case 3:
+        return new PrintCommand("3");
+        //null;
+      case 4:
+        return new PrintCommand("4");
+        //null;
+      case 5:
+        return new PrintCommand("5");
+        //null;
+      case 6:
+        return new PrintCommand("6");
+        //null;
+      case 7:
+        return new PrintCommand("7");
+        //null;
+      case 8:
+        return new PrintCommand("8");
+        //null;
+      case 9:
+        return new PrintCommand("9");
+        //null;
+      case 10:
+        return new PrintCommand("10");
+        //null;
+      case 11:
+        return new PrintCommand("11");
+        //null;
+      default:
+        return null;
+    }}}
+

2026-2706-Robot-Code/src/main/java/frc/robot/commands/startShooter.java

@@ -0,0 +1,60 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.commands;
+
+import frc.robot.subsystems.ShooterSubsystem;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.RunCommand;
+
+import java.util.concurrent.TimeUnit;
+
+
+/** An example command that uses an example subsystem. */
+public class startShooter extends Command {
+  @SuppressWarnings("PMD.UnusedPrivateField")
+  private final ShooterSubsystem m_ShooterSubystsem;
+
+  /**
+   * Creates a new ExampleCommand.
+   *
+   * @param subsystem The subsystem used by this command.
+   */
+  public startShooter(ShooterSubsystem subsystem) {
+    m_ShooterSubystsem = subsystem;
+    // Use addRequirements() here to declare subsystem dependencies.
+    addRequirements(m_ShooterSubystsem);
+  }
+
+  // Called when the command is initially scheduled.
+  @Override
+  public void initialize() {
+
+  }
+
+
+  // Called every time the scheduler runs while the command is scheduled.
+  @Override
+  public void execute() {
+    System.out.println("in startShooter command");
+    if (m_ShooterSubystsem.isRPMinRange()) {
+      m_ShooterSubystsem.ready();
+    } else {
+      m_ShooterSubystsem.spinningUp();
+    }
+  }
+
+
+
+  // Called once the command ends or is interrupted.
+  @Override
+  public void end(boolean interrupted) {}
+
+  // Returns true when the command should end.
+  @Override
+  public boolean isFinished() {
+    return false;
+  }
+}
+