Merge pull request #207 from Spikes-2212-Programming-Guild/rani-add-voltages

Created setVoltage and implemented for tankDrive and arcadeDrive

Author: Spikes-2212

src/main/java/com/spikes2212/command/drivetrains/TankDrivetrain.java

@@ -2,6 +2,7 @@
 
 import com.spikes2212.command.DashboardedSubsystem;
 import edu.wpi.first.networktables.NetworkTable;
+import edu.wpi.first.wpilibj.RobotController;
 import edu.wpi.first.wpilibj.drive.DifferentialDrive;
 import edu.wpi.first.wpilibj.motorcontrol.MotorController;
 
@@ -31,18 +32,16 @@ public TankDrivetrain(String namespaceName, MotorController left, MotorControlle
         rightController.setInverted(true);
         drive = new DifferentialDrive(leftController, rightController);
     }
-    
+
     public TankDrivetrain(MotorController left, MotorController right) {
         this(getClassName(DEFAULT_NAMESPACE_NAME), left, right);
     }
 
     /**
      * Moves both sides of this drivetrain by the given speeds for each side.
      *
-     * @param speedLeft  the speed to set to the left side. Positive values move this side
-     *                   forward.
-     * @param speedRight the speed to set to the right side. Positive values move this side
-     *                   forward.
+     * @param speedLeft  the speed to set to the left side (-1 to 1). Positive values move this side forward
+     * @param speedRight the speed to set to the right side (-1 to 1). Positive values move this side forward
      */
     public void tankDrive(double speedLeft, double speedRight) {
         drive.tankDrive(speedLeft, speedRight);
@@ -51,42 +50,62 @@ public void tankDrive(double speedLeft, double speedRight) {
     /**
      * Moves both sides of this drivetrain by the given speeds for each side.
      *
-     * @param speedLeft    the speed to set to the left side. Positive values move this side
-     *                     forward.
-     * @param speedRight   the speed to set to the right side. Positive values move this side
-     *                     forward.
+     * @param speedLeft    the speed to set to the left side (-1 to 1). Positive values move this side forward
+     * @param speedRight   the speed to set to the right side (-1 to 1). Positive values move this side forward
      * @param squareInputs whether to square the given inputs before putting them in the speed controllers
      */
     public void tankDrive(double speedLeft, double speedRight, boolean squareInputs) {
         drive.tankDrive(speedLeft, speedRight, squareInputs);
     }
 
     /**
-     * Moves the drivetrain with the given forward and angular speed.
+     * Moves both sides of this drivetrain by the given voltages for each side.
+     *
+     * @param leftVoltage  the voltage to the left side (-1 to 1). Positive values move this side forward
+     * @param rightVoltage the voltage to the right side (-1 to 1). Positive values move this side forward
+     */
+    public void tankDriveVoltages(double leftVoltage, double rightVoltage) {
+        tankDrive(leftVoltage / RobotController.getBatteryVoltage(),
+                rightVoltage / RobotController.getBatteryVoltage());
+    }
+
+    /**
+     * Moves the drivetrain by the given forward and angular speed.
      *
-     * @param moveValue   the forward movement speed.
-     * @param rotateValue the angular movement speed. Positive values go clockwise.
+     * @param moveValue   the forward movement speed (-1 to 1)
+     * @param rotateValue the angular movement speed (-1 to 1). Positive values go clockwise
      */
     public void arcadeDrive(double moveValue, double rotateValue) {
         drive.arcadeDrive(moveValue, rotateValue);
     }
 
     /**
-     * Moves both sides of this drivetrain by the given speeds for each side.
+     * Moves the drivetrain by the given forward and angular speed.
      *
-     * @param moveValue    the forward movement speed.
-     * @param rotateValue  the angular movement speed. Positive values go clockwise.
+     * @param moveValue    the forward movement speed (-1 to 1)
+     * @param rotateValue  the angular movement speed (-1 to 1). Positive values go clockwise
      * @param squareInputs whether to square the given inputs before putting them in the speed controllers
      */
     public void arcadeDrive(double moveValue, double rotateValue, boolean squareInputs) {
         drive.arcadeDrive(moveValue, rotateValue, squareInputs);
     }
 
+    /**
+     * Moves the drivetrain by the given forward and angular voltage.
+     *
+     * @param moveVoltage  the forward movement voltage (-12 to 12)
+     * @param rotateVoltage the angular movement voltage (-12 to 12). Positive values go clockwise
+     */
+    public void arcadeDriveVoltages(double moveVoltage, double rotateVoltage) {
+        arcadeDrive(moveVoltage / RobotController.getBatteryVoltage(),
+                rotateVoltage / RobotController.getBatteryVoltage());
+    }
+
     /**
      * Moves the drivetrain while rotating it.
      *
-     * @param speed     the forward movement speed.
-     * @param curvature the rotational movement speed. Positive values go clockwise.
+     * @param speed     the forward movement speed (-1 to 1)
+     * @param curvature the rotational movement speed (-1 to 1). Positive values go clockwise
      */
     public void curvatureDrive(double speed, double curvature) {
         drive.curvatureDrive(speed, curvature, true);
@@ -95,21 +114,42 @@ public void curvatureDrive(double speed, double curvature) {
     /**
      * Moves the left side of this drivetrain by a given speed.
      *
-     * @param speedLeft the speed to set to the left side. Positive values move this side forward.
+     * @param speedLeft the speed to set to the left side (-1 to 1). Positive values move this side forward
      */
     public void setLeft(double speedLeft) {
         leftController.set(speedLeft);
     }
 
     /**
-     * Moves the right side of this drivetrain with a given speed.
+     * Moves the right side of this drivetrain by a given speed.
      *
-     * @param speedRight the speed to set to the right side. Positive values move this side forward.
+     * @param speedRight the speed to set to the right side (-1 to 1). Positive values move this side forward
      */
     public void setRight(double speedRight) {
         rightController.set(-speedRight);
     }
 
+    /**
+     * Moves the left side of this drivetrain by a given voltage.
+     *
+     * @param leftVoltage the voltage to set to the left side (-12 to 12). Positive values move this side forward
+     */
+    public void setLeftVoltage(double leftVoltage) {
+        leftController.set(leftVoltage / RobotController.getBatteryVoltage());
+    }
+
+    /**
+     * Moves the right side of this drivetrain by a given voltage.
+     *
+     * @param rightVoltage the voltage to set to the right side (-12 to 12). Positive values move this side forward
+     */
+    public void setRightVoltage(double rightVoltage) {
+        rightController.set(rightVoltage / RobotController.getBatteryVoltage());
+    }
+
+    /**
+     * Stops the drivetrain.
+     */
     public void stop() {
         leftController.stopMotor();
         rightController.stopMotor();

src/main/java/com/spikes2212/command/drivetrains/commands/DriveArcade.java

@@ -6,8 +6,7 @@
 import java.util.function.Supplier;
 
 /**
- * This command moves a {@link TankDrivetrain} by linear and rotational speeds, using
- * the arcade control method written by WPILIB.
+ * A command that moves a {@link TankDrivetrain} using linear and rotational speeds.
  *
  * @author Yuval Levy
  * @see TankDrivetrain
@@ -26,7 +25,7 @@ public class DriveArcade extends CommandBase {
     protected final boolean squareInputs;
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values from Double {@link Supplier}s
      * for linear and rotational movements.
      *
@@ -49,7 +48,7 @@ public DriveArcade(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values from Double {@link Supplier}s
      * for linear and rotational movements. Does not square the inputs.
      *
@@ -66,7 +65,7 @@ public DriveArcade(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values from Double {@link Supplier}s
      * for linear and rotational movements.
      *
@@ -83,7 +82,7 @@ public DriveArcade(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values from Double {@link Supplier}s
      * for linear and rotational movements. Does not square the inputs.
      *
@@ -99,7 +98,7 @@ public DriveArcade(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values for linear and rotational movements.
      *
      * @param drivetrain   the tank drivetrain this command operates on
@@ -114,7 +113,7 @@ public DriveArcade(TankDrivetrain drivetrain, double moveValue,
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values for linear and rotational movements. Does not square the inputs.
      *
      * @param drivetrain   the tank drivetrain this command operates on
@@ -128,7 +127,7 @@ public DriveArcade(TankDrivetrain drivetrain, double moveValue,
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values for linear and rotational movements.
      *
      * @param drivetrain   the tank drivetrain this command operates on
@@ -142,7 +141,7 @@ public DriveArcade(TankDrivetrain drivetrain, double moveValue,
     }
 
     /**
-     * This constructs a new {@link DriveArcade} command that moves the given
+     * Constructs a new {@link DriveArcade} command that moves the given
      * {@link TankDrivetrain} according to speed values for linear and rotational movements. Does not square the inputs.
      *
      * @param drivetrain   the tank drivetrain this command operates on
@@ -156,7 +155,7 @@ public DriveArcade(TankDrivetrain drivetrain, double moveValue,
 
     @Override
     public void execute() {
-        tankDrivetrain.arcadeDrive(moveValueSupplier.get(), rotateValueSupplier.get());
+        tankDrivetrain.arcadeDrive(moveValueSupplier.get(), rotateValueSupplier.get(), squareInputs);
     }
 
     @Override

src/main/java/com/spikes2212/command/drivetrains/commands/DriveArcadeWithVoltages.java

@@ -0,0 +1,99 @@
+package com.spikes2212.command.drivetrains.commands;
+
+import java.util.function.Supplier;
+
+import com.spikes2212.command.drivetrains.TankDrivetrain;
+import edu.wpi.first.wpilibj2.command.CommandBase;
+
+/**
+ * A command that moves a {@link TankDrivetrain} using linear and rotational voltages.
+ *
+ * @author Yuval Levy
+ * @see TankDrivetrain
+ */
+
+public class DriveArcadeWithVoltages extends CommandBase {
+
+    protected final TankDrivetrain tankDrivetrain;
+    protected final Supplier<Double> moveValueSupplier;
+    protected final Supplier<Double> rotateValueSupplier;
+    protected final Supplier<Boolean> isFinished;
+
+    /**
+     * Constructs a new {@link DriveArcade} command that moves the given
+     * {@link TankDrivetrain} according to voltage values from Double {@link Supplier}s
+     * for linear and rotational movements.
+     *
+     * @param drivetrain          the tank drivetrain this command operates on
+     * @param moveValueSupplier   the double {@link Supplier} supplying the linear voltage (-12 to 12).
+     *                            Positive values go forwards
+     * @param rotateValueSupplier the double {@link Supplier} supplying the rotational voltage (-12 to 12).
+     *                            Positive values go clockwise
+     * @param isFinished          when to finish the command
+     */
+    public DriveArcadeWithVoltages(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier,
+                                   Supplier<Double> rotateValueSupplier, Supplier<Boolean> isFinished) {
+        addRequirements(drivetrain);
+        this.tankDrivetrain = drivetrain;
+        this.moveValueSupplier = moveValueSupplier;
+        this.rotateValueSupplier = rotateValueSupplier;
+        this.isFinished = isFinished;
+    }
+
+    /**
+     * Constructs a new {@link DriveArcade} command that moves the given
+     * {@link TankDrivetrain} according to voltage values from Double {@link Supplier}s
+     * for linear and rotational movements.
+     *
+     * @param drivetrain          the tank drivetrain this command operates on
+     * @param moveValueSupplier   the double {@link Supplier} supplying the linear voltage (-12 to 12).
+     *                            Positive values go forwards
+     * @param rotateValueSupplier the double {@link Supplier} supplying the rotational voltage (-12 to 12).
+     *                            Positive values go clockwise
+     */
+    public DriveArcadeWithVoltages(TankDrivetrain drivetrain, Supplier<Double> moveValueSupplier,
+                                   Supplier<Double> rotateValueSupplier) {
+        this(drivetrain, moveValueSupplier, rotateValueSupplier, () -> false);
+    }
+
+    /**
+     * Constructs a new {@link DriveArcade} command that moves the given
+     * {@link TankDrivetrain} according to voltage values for linear and rotational movements.
+     *
+     * @param drivetrain  the tank drivetrain this command operates on
+     * @param moveValue   the linear voltage (-12 to 12). Positive values go forwards
+     * @param rotateValue the rotational voltage (-12 to 12). Positive values go clockwise
+     * @param isFinished  when to finish the command
+     */
+    public DriveArcadeWithVoltages(TankDrivetrain drivetrain, double moveValue, double rotateValue,
+                                   Supplier<Boolean> isFinished) {
+        this(drivetrain, () -> moveValue, () -> rotateValue, isFinished);
+    }
+
+    /**
+     * Constructs a new {@link DriveArcade} command that moves the given
+     * {@link TankDrivetrain} according to voltage values for linear and rotational movements.
+     *
+     * @param drivetrain  the tank drivetrain this command operates on
+     * @param moveValue   the linear voltage (-12 to 12). Positive values go forwards
+     * @param rotateValue the rotational voltage (-12 to 12). Positive values go clockwise
+     */
+    public DriveArcadeWithVoltages(TankDrivetrain drivetrain, double moveValue, double rotateValue) {
+        this(drivetrain, () -> moveValue, () -> rotateValue, () -> false);
+    }
+
+    @Override
+    public void execute() {
+        tankDrivetrain.arcadeDriveVoltages(moveValueSupplier.get(), rotateValueSupplier.get());
+    }
+
+    @Override
+    public boolean isFinished() {
+        return isFinished.get();
+    }
+
+    @Override
+    public void end(boolean interrupted) {
+        tankDrivetrain.stop();
+    }
+}