simplified intakeEject open/close code

made toggleRightIntake and toggleLeftIntake simpler --> just uses
booleans but does put result into a pref
kForward now = closed and kReverse = closed (as it actually is in real
life)
changed a few SD keys in RobotMap for intake solenoid ports to be
clearer as to what they should be
"drawbacks": toggle methods do not take inversion into account, but
having that is the same as being able to change ports through SD (which
we do have the capability to do); needs testing to see if ports are
correct

Author: lhmcgann

Robot2018/src/org/usfirst/frc/team199/Robot2018/RobotMap.java

@@ -127,10 +127,10 @@ public RobotMap() {
 
 		leftIntakeMotor = new VictorSP(getPort("IntakeLeftVictorSP", 8));
 		rightIntakeMotor = new VictorSP(getPort("IntakeRightVictorSP", 9));
-		leftIntakeSolenoid = new DoubleSolenoid(getPort("IntakeLeftHorizontalSolenoidPort1", 4),
-				getPort("IntakeLeftHorizontalSolenoidPort2", 5));
-		rightIntakeSolenoid = new DoubleSolenoid(getPort("IntakeRightHorizontalSolenoidPort1", 2),
-				getPort("IntakeRightHorizontalSolenoidPort2", 3));
+		leftIntakeSolenoid = new DoubleSolenoid(getPort("IntakeLeftSolenoidForward", 4),
+				getPort("IntakeLeftSolenoidReverse", 5));
+		rightIntakeSolenoid = new DoubleSolenoid(getPort("IntakeRightSolenoidForward", 2),
+				getPort("IntakeRightSolenoidReverse", 3));
 
 		leftEncPort1 = new DigitalInput(getPort("1LeftEnc", 2));
 		leftEncPort2 = new DigitalInput(getPort("2LeftEnc", 3));

Robot2018/src/org/usfirst/frc/team199/Robot2018/subsystems/IntakeEject.java

@@ -11,44 +11,48 @@
 import edu.wpi.first.wpilibj.command.Subsystem;
 
 /**
- *
+ * kForward = intake closed, kReverse = intake open
  */
 public class IntakeEject extends Subsystem implements IntakeEjectInterface {
 	private final PowerDistributionPanel pdp = RobotMap.pdp;
 	private final VictorSP leftIntakeMotor = RobotMap.leftIntakeMotor;
 	private final VictorSP rightIntakeMotor = RobotMap.rightIntakeMotor;
 	private final DoubleSolenoid leftSolenoid = RobotMap.leftIntakeSolenoid;
 	private final DoubleSolenoid rightSolenoid = RobotMap.rightIntakeSolenoid;
-	private boolean leftOpen = isForw(leftSolenoid.get());
-	private boolean rightOpen = isForw(rightSolenoid.get());
+	private boolean leftOpen = isOpen(leftSolenoid.get());
+	private boolean rightOpen = isOpen(rightSolenoid.get());
 
 	/**
-	 * Return whether or not the doubleSolenoid is set to open
+	 * Return whether or not a side of the intake (L/R) is open
 	 * 
 	 * @param val
-	 *            The value of the doublesolenoid
+	 *            The value (kForward, kReverse, kOff) of the DoubleSolenoid for one
+	 *            side of the intake
 	 */
-	public boolean isForw(DoubleSolenoid.Value val) {
-		return val == DoubleSolenoid.Value.kForward;
+	public boolean isOpen(DoubleSolenoid.Value val) {
+		return val == DoubleSolenoid.Value.kReverse;
 	}
 
 	/**
 	 * Set the default command for a subsystem here.
 	 */
+	@Override
 	public void initDefaultCommand() {
 		setDefaultCommand(new DefaultIntake());
 	}
 
 	/**
 	 * @return current left motor value
 	 */
+	@Override
 	public double getLeftIntakeSpeed() {
 		return leftIntakeMotor.get();
 	}
 
 	/**
 	 * @return current right motor value
 	 */
+	@Override
 	public double getRightIntakeSpeed() {
 		return rightIntakeMotor.get();
 	}
@@ -58,6 +62,7 @@ public double getRightIntakeSpeed() {
 	 * robot
 	 * 
 	 */
+	@Override
 	public boolean hasCube() {
 		return pdp.getCurrent(Robot.rmap.getPort("PDP Intake Left Channel", 4)) > Robot.getConst("Max Current", 39)
 				|| pdp.getCurrent(Robot.rmap.getPort("PDP Intake Right Channel", 11)) > Robot.getConst("Max Current",
@@ -68,6 +73,7 @@ public boolean hasCube() {
 	 * stops the motors
 	 * 
 	 */
+	@Override
 	public void stopIntake() {
 		leftIntakeMotor.stopMotor();
 		rightIntakeMotor.stopMotor();
@@ -79,6 +85,7 @@ public void stopIntake() {
 	 * @param speed
 	 *            Speed the left motor should run at
 	 */
+	@Override
 	public void runLeftIntake(double speed) {
 		double actualSpeed = speed * Robot.getConst("Intake Motor Speed Multiplier", 0.5);
 		leftIntakeMotor.set(actualSpeed);
@@ -90,6 +97,7 @@ public void runLeftIntake(double speed) {
 	 * @param speed
 	 *            Speed the left motor should run at
 	 */
+	@Override
 	public void runRightIntake(double speed) {
 		double actualSpeed = speed * Robot.getConst("Intake Motor Speed Multiplier", 0.5);
 		rightIntakeMotor.set(actualSpeed);
@@ -101,81 +109,48 @@ public void runRightIntake(double speed) {
 	 * @param speed
 	 *            - negative -> rollers in, positive -> rollers out
 	 */
+	@Override
 	public void runIntake(double speed) {
 		runLeftIntake(speed);
 		runRightIntake(speed);
 	}
 
 	/**
-	 * Toggles the left intake between open and closed Laura's that works because it
-	 * has been TESTED
+	 * Toggles the left intake between open (kReverse) and closed (kForward).
 	 */
-	// public void toggleLeftIntake() {
-	// if (leftOpen) {
-	// // set to closed
-	// leftHorizontalSolenoid.set(DoubleSolenoid.Value.kReverse);
-	// } else {
-	// // set to open
-	// leftHorizontalSolenoid.set(DoubleSolenoid.Value.kForward);
-	// }
-	// leftOpen = !leftOpen;
-	// }
-
-	/**
-	 * Takes into account SmartDashboard keys and current position to toggle the
-	 * position of one of the horizontal solenoids
-	 * 
-	 * @param left
-	 *            Whether or not the solenoid to toggle is the left solenoid
-	 * @return The DoubleSolenoid.Value that the solenoid should be set to
-	 */
-	public DoubleSolenoid.Value toggleHorizontal(boolean left) {
-		boolean open = left ? leftOpen : rightOpen;
-		String side = left ? "Left" : "Right";
-		String key = "Intake " + side + " Horizontal Solenoid Inverted";
-		boolean inverted = Robot.getBool(key, false);
-		if ((open && inverted) || (!open && !inverted)) {
-			return DoubleSolenoid.Value.kForward;
+	@Override
+	public void toggleLeftIntake() {
+		if (leftOpen) {
+			// set to closed
+			leftSolenoid.set(DoubleSolenoid.Value.kForward);
 		} else {
-			return DoubleSolenoid.Value.kReverse;
+			// set to open
+			leftSolenoid.set(DoubleSolenoid.Value.kReverse);
 		}
-	}
-
-	/**
-	 * Laura's thing that "works" because it has been tested
-	 */
-	// public void toggleRightIntake() {
-	// if (rightOpen) {
-	// // set to closed
-	// rightHorizontalSolenoid.set(DoubleSolenoid.Value.kReverse);
-	// } else {
-	// // set to open
-	// rightHorizontalSolenoid.set(DoubleSolenoid.Value.kForward);
-	// }
-	// rightOpen = !rightOpen;
-	// }
-
-	/**
-	 * Toggles the left intake between open and closed
-	 */
-	public void toggleLeftIntake() {
-		leftSolenoid.set(toggleHorizontal(true));
 		leftOpen = !leftOpen;
 		Preferences.getInstance().putBoolean("Left Horizontal Solenoid Open", leftOpen);
 	}
 
 	/**
-	 * Toggles the right intake between open and closed
+	 * Toggles the right intake between open (kReverse) and closed (kForward).
 	 */
+	@Override
 	public void toggleRightIntake() {
-		rightSolenoid.set(toggleHorizontal(false));
+		if (rightOpen) {
+			// set to closed
+			rightSolenoid.set(DoubleSolenoid.Value.kForward);
+		} else {
+			// set to open
+			rightSolenoid.set(DoubleSolenoid.Value.kReverse);
+		}
 		rightOpen = !rightOpen;
-		Preferences.getInstance().putBoolean("Right Horizontal Solenoid Open", rightOpen);
+		Preferences.getInstance().putBoolean("Right Solenoid Open", rightOpen);
 	}
 
 	/**
 	 * Closes the intake
 	 */
+	@Override
 	public void closeIntake() {
 		if (leftOpen) {
 			toggleLeftIntake();
@@ -188,6 +163,7 @@ public void closeIntake() {
 	/**
 	 * Opens the intake
 	 */
+	@Override
 	public void openIntake() {
 		if (!leftOpen) {
 			toggleLeftIntake();