Initial Ports and Controls

build.gradle

@@ -1,6 +1,6 @@
 plugins {
     id "java"
-    id "edu.wpi.first.GradleRIO" version "2020.1.2"
+    id "edu.wpi.first.GradleRIO" version "2020.3.2"
 }
 
 sourceCompatibility = JavaVersion.VERSION_11

src/main/java/frc/robot/BallChucker9000.java

@@ -21,48 +21,45 @@
 
 import edu.wpi.first.wpilibj.DigitalInput;
 import edu.wpi.first.wpilibj.Encoder;
-import edu.wpi.first.wpilibj.Solenoid;
-import edu.wpi.first.wpilibj.VictorSP;
+import edu.wpi.first.wpilibj.SpeedController;
 
 public class BallChucker9000 {
 
     // ESC declarations
-    private final VictorSP rotatorMotor;
-    private final VictorSP flywheelMotor;
-    private final VictorSP indexerMotor;
+    private final SpeedController leftFlywheelMotor;
+    private final SpeedController rightFlywheelMotor;
+    private final SpeedController rotatorMotor;
+    private final SpeedController indexerMotor;
 
     // Encoder declarations
     private final Encoder rotatorEncoder;
     private final Encoder flywheelEncoder;
 
-    // Piston declarations
-    private final Solenoid indexerPiston;
-
     // Limit switches
     private final DigitalInput rotatorAtZeroSwitch;
 
     // Class initializer
-    public BallChucker9000(int flywheelMotorPort, int rotatorMotorPort, int indexerMotorPort,
-            int rotatorEncoderChannelA, int rotatorEncoderChannelB, int flywheelEncoderChannelA,
-            int flywheelEncoderChannelB, int indexerPistonPort, int rotatorAtZeroSwitchPort) {
+    public BallChucker9000(SpeedController leftFlywheelMotor, SpeedController rightFlywheelMotor,
+            SpeedController rotatorMotor, SpeedController indexerMotor, int rotatorEncoderChannelA,
+            int rotatorEncoderChannelB, int flywheelEncoderChannelA, int flywheelEncoderChannelB,
+            int rotatorAtZeroSwitchPort) {
 
         // ESCs
-        flywheelMotor = new VictorSP(flywheelMotorPort);
-        rotatorMotor = new VictorSP(rotatorMotorPort);
-        indexerMotor = new VictorSP(indexerMotorPort);
+        this.leftFlywheelMotor = leftFlywheelMotor;
+        this.rightFlywheelMotor = rightFlywheelMotor;
+        this.rotatorMotor = rotatorMotor;
+        this.indexerMotor = indexerMotor;
 
         // Encoders
         rotatorEncoder = new Encoder(rotatorEncoderChannelA, rotatorEncoderChannelB);
         flywheelEncoder = new Encoder(flywheelEncoderChannelA, flywheelEncoderChannelB);
-        rotatorEncoder.setDistancePerPulse(1.0 / 1024.0);
-        flywheelEncoder.setDistancePerPulse(1.0 / 1024.0);
 
-        // Piston
-        indexerPiston = new Solenoid(indexerPistonPort);
+        // 50 to 1 gearbox. Gear on output shaft has 15 teeth, sprocket has 124 teeth
+        rotatorEncoder.setDistancePerPulse(15.0 * 360.0 / (50.0 * 124.0 * 1024.0));
+        flywheelEncoder.setDistancePerPulse(1.0 / 1024.0);
 
         // Limit switches
         rotatorAtZeroSwitch = new DigitalInput(rotatorAtZeroSwitchPort);
-
     }
 
     // Reset the encoder to zero when called
@@ -74,25 +71,29 @@ public void update() {
 
     // Setters
 
-    // ESC
-    public void rotatorMotorControl(double power) {
+    /**
+     * 
+     * @param power positive is counter clockwise, scaled down by a factor of 10
+     */
+    public void moveRotator(double power) {
+        power = 0.1 * Math.copySign(Math.min(Math.abs(power), 1), power);
         rotatorMotor.set(power);
     }
 
-    public void flywheelMotorControl(double power) {
-        flywheelMotor.set(power);
+    public void moveFlywheel(double power) {
+        leftFlywheelMotor.set(power);
+        rightFlywheelMotor.set(power);
     }
 
-    public void indexerMotorControl(double power) {
+    public void moveIndexer(double power) {
         indexerMotor.set(power);
     }
 
-    // Pistons
-    public void indexerPistonOut(boolean state) {
-        indexerPiston.set(state);
+    // Getters
+    public double getRotatorEncoder() {
+        return rotatorEncoder.getDistance();
     }
 
-    // Getters
     public double getFlywheelEncoder() {
         return flywheelEncoder.getRate();
     }
@@ -101,5 +102,4 @@ public double getFlywheelEncoder() {
     public boolean getRotatorAtZeroSwitch() {
         return !rotatorAtZeroSwitch.get();
     }
-
 }

src/main/java/frc/robot/BallTransfer.java

@@ -1,18 +1,19 @@
 package frc.robot;
 
-import edu.wpi.first.wpilibj.VictorSP;
+import edu.wpi.first.wpilibj.SpeedController;
 
 public class BallTransfer {
 
-    private final VictorSP beltMotor;
+    private final SpeedController beltMotor;
 
-    public BallTransfer(int beltMotorPort) {
-        beltMotor = new VictorSP(beltMotorPort);
+    public BallTransfer(SpeedController beltMotor) {
+        this.beltMotor = beltMotor;
     }
 
     /**
      * 
-     * @param power positive to move ball towards Ball Chucker 9000, negative to move ball towards Harvester
+     * @param power positive to move ball towards Ball Chucker 9000, negative to
+     *              move ball towards Harvester
      */
     public void moveBalls(double power) {
         beltMotor.set(power);

src/main/java/frc/robot/Climb.java

@@ -1,29 +1,50 @@
 package frc.robot;
 
-import edu.wpi.first.wpilibj.VictorSP;
 import edu.wpi.first.wpilibj.DigitalInput;
+import edu.wpi.first.wpilibj.Solenoid;
+import edu.wpi.first.wpilibj.SpeedController;
 
 public class Climb {
 
-    private final VictorSP winchMotor;
-    private final VictorSP armMotor;
+    private final SpeedController winchMotor;
+    private final SpeedController armMotor;
+
+    private final Solenoid winchLockPiston;
 
     private DigitalInput armLimitSwitch;
 
-    public Climb(int winchMotorPort, int armMotorPort, int armLimitSwitchPort) {
-        winchMotor = new VictorSP(winchMotorPort);
-        armMotor = new VictorSP(armMotorPort);
+    public Climb(SpeedController winchMotor, SpeedController armMotor, int armLockPistonPort, int armLimitSwitchPort) {
+        this.winchMotor = winchMotor;
+        this.armMotor = armMotor;
+        winchLockPiston = new Solenoid(armLockPistonPort);
+
         armLimitSwitch = new DigitalInput(armLimitSwitchPort);
     }
 
     public void runWinch(double power) {
-        winchMotor.set(power);
+        if (!lockLocked()) {
+            winchMotor.set(power);
+        } else {
+            winchMotor.set(0);
+        }
     }
 
-    public void moveArms(double power) {
+    public void moveArm(double power) {
         armMotor.set(power);
     }
 
+    public void lock(boolean on) {
+        winchLockPiston.set(!on);
+    }
+
+    public void toggleLock() {
+        lock(!lockLocked());
+    }
+
+    public boolean lockLocked() {
+        return !winchLockPiston.get();
+    }
+
     public boolean getArmLimitSwitchValue() {
         return !armLimitSwitch.get();
     }

src/main/java/frc/robot/DriveBase.java

@@ -2,63 +2,83 @@
 
 import edu.wpi.first.wpilibj.ADXRS450_Gyro;
 import edu.wpi.first.wpilibj.CounterBase.EncodingType;
+import edu.wpi.first.wpilibj.drive.DifferentialDrive;
 import edu.wpi.first.wpilibj.Encoder;
 import edu.wpi.first.wpilibj.Solenoid;
-import edu.wpi.first.wpilibj.VictorSP;
+import edu.wpi.first.wpilibj.SpeedControllerGroup;
 
-public class DriveBase {
+public class DriveBase extends DifferentialDrive {
 
-    private final VictorSP driveLeft;
-    private final VictorSP driveRight;
-    private final Solenoid shifter;
+    private final SpeedControllerGroup driveLeft;
+    private final SpeedControllerGroup driveRight;
+
+    private final Solenoid leftShifter;
+    private final Solenoid rightShifter;
 
     private final Encoder leftEncoder;
     private final Encoder rightEncoder;
 
-    private final ADXRS450_Gyro gyro;
-
     private boolean usingLeftEncoder = false;
 
     private double heading;
     public double courseHeading;
 
-    public DriveBase(int left, int right, int leftA, int leftB, int rightA, int rightB, int shifterChannel) {
-        driveLeft = new VictorSP(left);
-        driveRight = new VictorSP(right);
+    /**
+     * 
+     * @param driveLeft           positive moves forward. the front of the robot is
+     *                            opposite the intake.
+     * @param driveRight
+     * @param leftShifterChannel
+     * @param rightShifterChannel
+     * @param leftA
+     * @param leftB
+     * @param rightA
+     * @param rightB
+     */
+    public DriveBase(SpeedControllerGroup driveLeft, SpeedControllerGroup driveRight, int leftShifterChannel,
+            int rightShifterChannel, int leftA, int leftB, int rightA, int rightB) {
+        super(driveLeft, driveRight);
+        this.driveLeft = driveLeft;
+        this.driveRight = driveRight;
+
+        leftShifter = new Solenoid(leftShifterChannel);
+        rightShifter = new Solenoid(rightShifterChannel);
 
         leftEncoder = new Encoder(leftA, leftB, false, EncodingType.k4X);
         rightEncoder = new Encoder(rightA, rightB, true, EncodingType.k4X);
 
         leftEncoder.setDistancePerPulse((4 * Math.PI) / 1024.0);
         rightEncoder.setDistancePerPulse((4 * Math.PI) / 1024.0);
-
-        shifter = new Solenoid(shifterChannel);
-
-        gyro = new ADXRS450_Gyro();
-        gyro.calibrate();
-        heading = gyro.getAngle();
-        courseHeading = heading;
     }
 
     public void drive(double leftPower, double rightPower) {
         driveLeft.set(leftPower);
-        driveRight.set(-rightPower);
+        driveRight.set(rightPower);
     }
 
     public void drive(double power) {
         drive(power, power);
     }
 
     public void useHighGear(boolean highGear) {
-        shifter.set(highGear);
+        leftShifter.set(highGear);
+        rightShifter.set(highGear);
+    }
+
+    public boolean getShifterState() {
+        return leftShifter.get();
+    }
+
+    public void toggleHighGear() {
+        useHighGear(!getShifterState());
     }
 
     public void resetGyro() {
-        gyro.reset();
+        // TODO: NOPE
     }
 
     public double getGyroAngle() {
-        return gyro.getAngle();
+        return 0;
     }
 
     public void resetEncoders() {

src/main/java/frc/robot/Harvester.java

@@ -1,21 +1,28 @@
 package frc.robot;
 
-import edu.wpi.first.wpilibj.VictorSP;
 import edu.wpi.first.wpilibj.Solenoid;
+import edu.wpi.first.wpilibj.SpeedController;
 
 public class Harvester {
 
     // ESC declarations
-    private final VictorSP intakeMotor; 
+    private final SpeedController intakeMotor;
 
     // Piston declarations
-    private final Solenoid deployerPiston;
+    private final Solenoid portDeployerPiston;
+    private final Solenoid starboardDeployerPiston;
 
-
-    // class initializer
-    public Harvester(int intakeMotorPort, int deployPistonPort) {
-        intakeMotor = new VictorSP(intakeMotorPort);
-        deployerPiston = new Solenoid(deployPistonPort);
+    /**
+     * 
+     * @param intakeMotor
+     * @param portDeployPistonPort        This is the left piston, relative to the
+     *                                    front being the climb side of the robot
+     * @param starboardDeployerPistonPort This is the right piston.
+     */
+    public Harvester(SpeedController intakeMotor, int portDeployPistonPort, int starboardDeployerPistonPort) {
+        this.intakeMotor = intakeMotor;
+        portDeployerPiston = new Solenoid(portDeployPistonPort);
+        starboardDeployerPiston = new Solenoid(starboardDeployerPistonPort);
     }
 
     // Setters
@@ -28,8 +35,17 @@ public void intakeMotorControl(double power) {
         intakeMotor.set(power);
     }
 
-    // Piston
-    public void delpoyIntake(boolean deployed) {
-        deployerPiston.set(deployed);
+    // Pistons
+    public void deployIntake(boolean deployed) {
+        portDeployerPiston.set(deployed);
+        starboardDeployerPiston.set(deployed);
+    }
+
+    public boolean deployerDeployed() {
+        return portDeployerPiston.get();
+    }
+
+    public void toggleDeployer() {
+        deployIntake(!deployerDeployed());
     }
 }

src/main/java/frc/robot/Main.java

@@ -11,8 +11,8 @@
 
 /**
  * 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.
+ * 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() {
@@ -21,7 +21,8 @@ private Main() {
   /**
    * Main initialization function. Do not perform any initialization here.
    *
-   * <p>If you change your main robot class, change the parameter type.
+   * <p>
+   * If you change your main robot class, change the parameter type.
    */
   public static void main(String... args) {
     RobotBase.startRobot(Robot::new);