Initial commit

src/main/java/frc4388/robot/Constants.java

@@ -0,0 +1,38 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018-2019 FIRST. All Rights Reserved.                        */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot;
+
+import frc4388.utility.LEDPatterns;
+
+/**
+ * The Constants class provides a convenient place for teams to hold robot-wide numerical or boolean
+ * constants.  This class should not be used for any other purpose.  All constants should be
+ * declared globally (i.e. public static).  Do not put anything functional in this class.
+ *
+ * <p>It is advised to statically import this class (or one of its inner classes) wherever the
+ * constants are needed, to reduce verbosity.
+ */
+public final class Constants {
+    public static final class DriveConstants {
+        public static final int DRIVE_LEFT_FRONT_CAN_ID = 2;
+        public static final int DRIVE_RIGHT_FRONT_CAN_ID = 4;
+	    public static final int DRIVE_LEFT_BACK_CAN_ID = 3;
+	    public static final int DRIVE_RIGHT_BACK_CAN_ID = 5;
+    }
+
+    public static final class LEDConstants {
+        public static final int LED_SPARK_ID = 0;
+
+        public static final LEDPatterns DEFAULT_PATTERN = LEDPatterns.FOREST_WAVES;
+    }
+
+    public static final class OIConstants {
+        public static final int XBOX_DRIVER_ID = 0;
+        public static final int XBOX_OPERATOR_ID = 1;
+    }
+}

src/main/java/frc4388/robot/Main.java

@@ -0,0 +1,29 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot;
+
+import edu.wpi.first.wpilibj.RobotBase;
+
+/**
+ * Do NOT add any static variables to this class, or any initialization at all.
+ * Unless you know what you are doing, do not modify this file except to
+ * change the parameter class to the startRobot call.
+ */
+public final class Main {
+  private Main() {
+  }
+
+  /**
+   * Main initialization function. Do not perform any initialization here.
+   *
+   * <p>If you change your main robot class, change the parameter type.
+   */
+  public static void main(String... args) {
+    RobotBase.startRobot(Robot::new);
+  }
+}

src/main/java/frc4388/robot/Robot.java

@@ -0,0 +1,119 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2017-2019 FIRST. All Rights Reserved.                        */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot;
+
+import edu.wpi.first.wpilibj.TimedRobot;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.CommandScheduler;
+
+/**
+ * The VM is configured to automatically run this class, and to call the
+ * functions corresponding to each mode, as described in the TimedRobot
+ * documentation. If you change the name of this class or the package after
+ * creating this project, you must also update the build.gradle file in the
+ * project.
+ */
+public class Robot extends TimedRobot {
+  Command m_autonomousCommand;
+
+  private RobotContainer m_robotContainer;
+
+  /**
+   * This function is run when the robot is first started up and should be
+   * used for any initialization code.
+   */
+  @Override
+  public void robotInit() {
+    // Instantiate our RobotContainer.  This will perform all our button bindings, and put our
+    // autonomous chooser on the dashboard.
+    m_robotContainer = new RobotContainer();
+  }
+
+  /**
+   * This function is called every robot packet, no matter the mode. Use
+   * this for items like diagnostics that you want ran during disabled,
+   * autonomous, teleoperated and test.
+   *
+   * <p>This runs after the mode specific periodic functions, but before
+   * LiveWindow and SmartDashboard integrated updating.
+   */
+  @Override
+  public void robotPeriodic() {
+    // Runs the Scheduler.  This is responsible for polling buttons, adding newly-scheduled
+    // commands, running already-scheduled commands, removing finished or interrupted commands,
+    // and running subsystem periodic() methods.  This must be called from the robot's periodic
+    // block in order for anything in the Command-based framework to work.
+    CommandScheduler.getInstance().run();
+  }
+
+  /**
+   * This function is called once each time the robot enters Disabled mode.
+   * You can use it to reset any subsystem information you want to clear when
+   * the robot is disabled.
+   */
+  @Override
+  public void disabledInit() {
+  }
+
+  @Override
+  public void disabledPeriodic() {
+  }
+
+  /**
+   * This autonomous runs the autonomous command selected by your {@link RobotContainer} class.
+   */
+  @Override
+  public void autonomousInit() {
+    m_autonomousCommand = m_robotContainer.getAutonomousCommand();
+
+    /*
+     * String autoSelected = SmartDashboard.getString("Auto Selector",
+     * "Default"); switch(autoSelected) { case "My Auto": autonomousCommand
+     * = new MyAutoCommand(); break; case "Default Auto": default:
+     * autonomousCommand = new ExampleCommand(); break; }
+     */
+
+    // schedule the autonomous command (example)
+    if (m_autonomousCommand != null) {
+      m_autonomousCommand.schedule();
+    }
+  }
+
+  /**
+   * This function is called periodically during autonomous.
+   */
+  @Override
+  public void autonomousPeriodic() {
+  }
+
+  @Override
+  public void teleopInit() {
+    // This makes sure that the autonomous stops running when
+    // teleop starts running. If you want the autonomous to
+    // continue until interrupted by another command, remove
+    // this line or comment it out.
+    if (m_autonomousCommand != null) {
+      m_autonomousCommand.cancel();
+    }
+  }
+
+  /**
+   * This function is called periodically during operator control.
+   */
+  @Override
+  public void teleopPeriodic() {
+    
+  }
+
+  /**
+   * This function is called periodically during test mode.
+   */
+  @Override
+  public void testPeriodic() {
+  }
+}

src/main/java/frc4388/robot/RobotContainer.java

@@ -0,0 +1,112 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018-2019 FIRST. All Rights Reserved.                        */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot;
+
+import edu.wpi.first.wpilibj.Joystick;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.InstantCommand;
+import edu.wpi.first.wpilibj2.command.RunCommand;
+import edu.wpi.first.wpilibj2.command.button.JoystickButton;
+import frc4388.robot.Constants.*;
+import frc4388.robot.subsystems.Drive;
+import frc4388.robot.subsystems.LED;
+import frc4388.utility.LEDPatterns;
+import frc4388.utility.controller.IHandController;
+import frc4388.utility.controller.XboxController;
+
+/**
+ * This class is where the bulk of the robot should be declared. Since
+ * Command-based is a "declarative" paradigm, very little robot logic should
+ * actually be handled in the {@link Robot} periodic methods (other than the
+ * scheduler calls). Instead, the structure of the robot (including subsystems,
+ * commands, and button mappings) should be declared here.
+ */
+public class RobotContainer {
+    /* Subsystems */
+    private final Drive m_robotDrive = new Drive();
+    private final LED m_robotLED = new LED();
+
+    /* Controllers */
+    private final XboxController m_driverXbox = new XboxController(OIConstants.XBOX_DRIVER_ID);
+    private final XboxController m_operatorXbox = new XboxController(OIConstants.XBOX_OPERATOR_ID);
+
+    /**
+     * The container for the robot.  Contains subsystems, OI devices, and commands.
+     */
+    public RobotContainer() {
+        configureButtonBindings();
+
+        /* Default Commands */
+        // drives the robot with a two-axis input from the driver controller
+        m_robotDrive.setDefaultCommand(new RunCommand(() -> m_robotDrive.driveWithInput(
+            getDriverController().getLeftYAxis(),
+            getDriverController().getRightXAxis())));
+        // continually sends updates to the Blinkin LED controller to keep the lights on
+        m_robotLED.setDefaultCommand(new RunCommand(() -> m_robotLED.updateLED()));
+    }
+
+    /**
+    * Use this method to define your button->command mappings.  Buttons can be created by
+    * instantiating a {@link GenericHID} or one of its subclasses ({@link
+    * edu.wpi.first.wpilibj.Joystick} or {@link XboxController}), and then passing it to a
+    * {@link edu.wpi.first.wpilibj2.command.button.JoystickButton}.
+    */
+    private void configureButtonBindings() {
+        /* Driver Buttons */
+        // test command to spin the robot while pressing A on the driver controller
+        new JoystickButton(getDriverJoystick(), XboxController.A_BUTTON)
+            .whileHeld(() -> m_robotDrive.driveWithInput(0, 1));
+
+        /* Operator Buttons */
+        // activates "Lit Mode"
+        new JoystickButton(getOperatorJoystick(), XboxController.A_BUTTON)
+            .whenPressed(() -> m_robotLED.setPattern(LEDPatterns.LAVA_RAINBOW))
+            .whenReleased(() -> m_robotLED.setPattern(LEDConstants.DEFAULT_PATTERN));
+    }
+
+    /**
+     * Use this to pass the autonomous command to the main {@link Robot} class.
+     *
+     * @return the command to run in autonomous
+     */
+    public Command getAutonomousCommand() {
+        // no auto
+        return new InstantCommand();
+    }
+
+    /**
+     * Add your docs here.
+     */
+    public IHandController getDriverController() {
+        return m_driverXbox;
+    }
+    
+    /**
+     * Add your docs here.
+     */
+    public IHandController getOperatorController()
+    {
+        return m_operatorXbox;
+    }
+    
+    /**
+     * Add your docs here.
+     */
+    public Joystick getOperatorJoystick()
+    {
+        return m_operatorXbox.getJoyStick();
+    }
+    
+    /**
+     * Add your docs here.
+     */
+    public Joystick getDriverJoystick()
+    {
+        return m_driverXbox.getJoyStick();
+    }
+}

src/main/java/frc4388/robot/subsystems/Drive.java

@@ -0,0 +1,66 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot.subsystems;
+
+import com.ctre.phoenix.motorcontrol.InvertType;
+import com.ctre.phoenix.motorcontrol.NeutralMode;
+import com.ctre.phoenix.motorcontrol.can.WPI_TalonSRX;
+
+import edu.wpi.first.wpilibj.drive.DifferentialDrive;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+
+import frc4388.robot.Constants.DriveConstants;
+
+/**
+ * Add your docs here.
+ */
+public class Drive extends SubsystemBase {
+  // Put methods for controlling this subsystem
+  // here. Call these from Commands.
+
+  public static WPI_TalonSRX m_leftFrontMotor = new WPI_TalonSRX(DriveConstants.DRIVE_LEFT_FRONT_CAN_ID);
+  public static WPI_TalonSRX m_rightFrontMotor = new WPI_TalonSRX(DriveConstants.DRIVE_RIGHT_FRONT_CAN_ID);
+  public static WPI_TalonSRX m_leftBackMotor = new WPI_TalonSRX(DriveConstants.DRIVE_LEFT_BACK_CAN_ID);
+  public static WPI_TalonSRX m_rightBackMotor = new WPI_TalonSRX(DriveConstants.DRIVE_RIGHT_BACK_CAN_ID);
+
+  public static DifferentialDrive m_driveTrain = new DifferentialDrive(m_leftFrontMotor, m_rightFrontMotor);
+
+  /**
+   * Add your docs here.
+   */
+  public Drive(){
+    /* factory default values */
+    m_leftFrontMotor.configFactoryDefault();
+    m_rightFrontMotor.configFactoryDefault();
+    m_leftBackMotor.configFactoryDefault();
+    m_rightBackMotor.configFactoryDefault();
+
+    /* set back motors as followers */
+    m_leftBackMotor.follow(m_leftFrontMotor);
+    m_rightBackMotor.follow(m_rightFrontMotor);
+
+    /* set neutral mode */
+    m_leftFrontMotor.setNeutralMode(NeutralMode.Brake);
+    m_rightFrontMotor.setNeutralMode(NeutralMode.Brake);
+    m_leftFrontMotor.setNeutralMode(NeutralMode.Brake);
+    m_rightFrontMotor.setNeutralMode(NeutralMode.Brake);
+
+    /* flip input so forward becomes back, etc */
+    m_leftFrontMotor.setInverted(false);
+    m_rightFrontMotor.setInverted(false);
+    m_leftBackMotor.setInverted(InvertType.FollowMaster);
+    m_rightBackMotor.setInverted(InvertType.FollowMaster);
+  }
+
+  /**
+   * Add your docs here.
+   */
+  public void driveWithInput(double move, double steer){
+    m_driveTrain.arcadeDrive(move, steer);
+  }
+}

src/main/java/frc4388/robot/subsystems/LED.java

@@ -0,0 +1,55 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Open Source Software - may be modified and shared by FRC teams. The code   */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project.                                                               */
+/*----------------------------------------------------------------------------*/
+
+package frc4388.robot.subsystems;
+
+import edu.wpi.first.wpilibj.Spark;
+import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+
+import frc4388.robot.Constants.LEDConstants;
+import frc4388.utility.LEDPatterns;
+
+/**
+ * Allows for the control of a 5v LED Strip using a Rev Robotics Blinkin LED
+ * Driver
+ */
+public class LED extends SubsystemBase {
+
+  public static float currentLED;
+  public static Spark LEDController;
+
+  /**
+   * Add your docs here.
+   */
+  public LED(){
+    LEDController = new Spark(LEDConstants.LED_SPARK_ID);
+    setPattern(LEDConstants.DEFAULT_PATTERN);
+    LEDController.set(currentLED);
+    System.err.println("In the Beginning, there was Joe.\nAnd he said, 'Let there be LEDs.'\nAnd it was good.");
+  }
+
+  /**
+   * Add your docs here.
+   */
+  public void updateLED(){
+    LEDController.set(currentLED);
+  }
+
+  /**
+   * Add your docs here.
+   */
+  public void setPattern(LEDPatterns pattern){
+    currentLED = pattern.getValue();
+    LEDController.set(currentLED);
+  }
+
+  @Override
+  public void periodic(){
+    SmartDashboard.putNumber("LED", currentLED);
+  }
+}