--- /dev/null
+package org.usfirst.frc.team3501.robot;
+
+import edu.wpi.first.wpilibj.DoubleSolenoid;
+
+/**
+ * The Constants stores constant values for all subsystems. This includes the
+ * port values for motors and sensors, as well as important operational
+ * constants for subsystems such as max and min values.
+ */
+
+public class Constants {
+ public static class OI {
+ // Computer Ports
+ public final static int LEFT_STICK_PORT = 0;
+ public final static int RIGHT_STICK_PORT = 1;
+ // Ports on the Joystick
+ public final static int TRIGGER_PORT = 1;
+ public final static int DECREMENT_SHOOTER_SPEED_PORT = 2;
+ public final static int INCREMENT_SHOOTER_SPEED_PORT = 3;
+ public final static int SHOOT_PORT = 4;
+ public final static int LOG_PORT = 5;
+ }
+
+ public static class DriveTrain {
+ // Drivetrain Motor Related Ports
+ public static final int FRONT_LEFT = 0;
+ public static final int FRONT_RIGHT = 0;
+ public static final int REAR_LEFT = 0;
+ public static final int REAR_RIGHT = 0;
+
+ // Encoder related ports
+ public final static int ENCODER_LEFT_A = 3;
+ public final static int ENCODER_LEFT_B = 4;
+ public final static int ENCODER_RIGHT_A = 2;
+ public final static int ENCODER_RIGHT_B = 1;
+
+ private final static double WHEEL_DIAMETER = 6.0; // in inches
+ private final static double PULSES_PER_ROTATION = 256; // in pulses
+ private final static double OUTPUT_SPROCKET_DIAMETER = 2.0; // in inches
+ private final static double WHEEL_SPROCKET_DIAMETER = 3.5; // in inches
+ public final static double INCHES_PER_PULSE = (((Math.PI)
+ * OUTPUT_SPROCKET_DIAMETER / PULSES_PER_ROTATION)
+ / WHEEL_SPROCKET_DIAMETER) * WHEEL_DIAMETER;
+ }
+
+ public static class Scaler {
+ // Piston channels
+ public final static int FORWARD_CHANNEL = 0;
+ public final static int REVERSE_CHANNEL = 0;
+
+ // Winch port
+ public final static int WINCH_MOTOR = 0;
+
+ }
+
+ public static class Shooter {
+ public static final int PORT = 0;
+ public static final int PUNCH_FORWARD_PORT = 0;
+ public static final int PUNCH_REVERSE_PORT = 1;
+ public static final int ANGLE_ADJUSTER_PORT = 0;
+
+ public static final DoubleSolenoid.Value punch = DoubleSolenoid.Value.kForward;
+ public static final DoubleSolenoid.Value retract = DoubleSolenoid.Value.kReverse;
+
+ // Encoder port
+ public static final int ENCODER_PORT_A = 0;
+ public static final int ENCODER_PORT_B = 0;
+
+ public static enum State {
+ RUNNING, STOPPED;
+ }
+ }
+
+ public static class IntakeArm {
+ public static final int ROLLER_PORT = 0;
+ public static final int ARM_PORT = 1;
+ public static final int POT_CHANNEL = 0;
+ public static final double INTAKE_SPEED = 0.5;
+ public static final double OUTPUT_SPEED = -0.5;
+ public final static double FULL_RANGE = 270.0; // in degrees
+ public final static double OFFSET = -135.0; // in degrees
+ public static final double ZERO_ANGLE = 0;
+ }
+
+ public static class DefenseArm {
+ // Potentiometer related ports
+ public static final int ARM_CHANNEL = 0;
+ public static final int ARM_PORT = 0;
+ public static final int HAND_PORT = 1;
+ public static final int HAND_CHANNEL = 1;
+ public final static double FULL_RANGE = 270.0; // in degrees
+ public final static double OFFSET = -135.0; // in degrees
+<<<<<<< HEAD
+ public final static double[] armPotValue = { 0.0, 45.0, 90.0 }; // 3
+ // level
+ public final static double ARM_LENGTH = 0; // TODO: find actual length
+ public final static double HAND_LENGTH = 0; // TODO: find actual length
+ public final static double ARM_MOUNTED_HEIGHT = 0; // TODO: find actual
+ // height
+=======
+ public final static double[] armPotValue = { 0.0, 45.0, 90.0 }; // 3 level
+ public final static double ARM_LENGTH = 0; // TODO: find actual length
+ public final static double HAND_LENGTH = 0; // TODO: find actual length
+ public final static double ARM_MOUNTED_HEIGHT = 0; // TODO: find actual
+ // height
+>>>>>>> add methods that return how far arm is sticking out and how high arm is at, and constants that need filling in
+ }
+
+ public enum Defense {
+ PORTCULLIS, SALLY_PORT, ROUGH_TERRAIN, LOW_BAR, CHEVAL_DE_FRISE, DRAWBRIDGE, MOAT, ROCK_WALL, RAMPART;
+ }
+}
--- /dev/null
+package org.usfirst.frc.team3501.robot.subsystems;
+
+import org.usfirst.frc.team3501.robot.Constants;
+
+import edu.wpi.first.wpilibj.AnalogPotentiometer;
+import edu.wpi.first.wpilibj.CANTalon;
+import edu.wpi.first.wpilibj.command.Subsystem;
+
+public class DefenseArm extends Subsystem {
+ private AnalogPotentiometer defenseArmPotentiometer;
+ private AnalogPotentiometer defenseHandPotentiometer;
+ private CANTalon defenseArm;
+ private CANTalon defenseHand;
+ private double hookHeight;
+ private double footHeight;
+<<<<<<< HEAD
+ private double[] potHandAngles;
+ private double[] potArmAngles;
+=======
+ private double[] potAngles = { 0, 45, 90 };
+>>>>>>> Fix some errors
+
+ // angles corresponding to pre-determined heights we will need
+
+ public DefenseArm() {
+ defenseArmPotentiometer = new AnalogPotentiometer(
+ Constants.DefenseArm.ARM_CHANNEL,
+ Constants.DefenseArm.FULL_RANGE,
+ Constants.DefenseArm.OFFSET);
+ defenseHandPotentiometer = new AnalogPotentiometer(
+ Constants.DefenseArm.HAND_CHANNEL,
+ Constants.DefenseArm.FULL_RANGE,
+ Constants.DefenseArm.OFFSET);
+
+ defenseArm = new CANTalon(Constants.DefenseArm.ARM_PORT);
+ defenseHand = new CANTalon(Constants.DefenseArm.HAND_PORT);
+<<<<<<< HEAD
+ potHandAngles = createHandPotArray();
+ potArmAngles = createArmPotArray();
+=======
+>>>>>>> Fix some errors
+ }
+
+ public double getArmPotAngle() {
+ return defenseArmPotentiometer.get();
+ }
+
+ public double getHandPotAngle() {
+ return defenseHandPotentiometer.get();
+ }
+
+ /***
+ * This method takes an arm location as input (range of [0,2])
+ * Returns the angle of the arm corresponding to that arm location
+ *
+ * @param desiredArmLocation
+ * takes an arm location ranging from [0,2]
+ * 0 is the lowest position of arm
+ * 2 is the highest position of arm
+ * @return
+ * the angle of the arm corresponding to that arm location
+ */
+<<<<<<< HEAD
+ public double getAngleForHandLocation(int desiredArmLocation) {
+ return potHandAngles[desiredArmLocation];
+ }
+
+ public double getAngleForArmLocation(int desiredArmLocation) {
+ return potArmAngles[desiredArmLocation];
+ }
+
+ public double[] createHandPotArray() {
+ double[] arr = new double[3];
+
+ for (int i = 0; i < 3; i++) {
+ arr[i] = 45 * i;
+ }
+ return arr;
+ }
+
+ public double[] createArmPotArray() {
+ double[] arr = new double[3];
+
+ for (int i = 0; i < 3; i++) {
+ arr[i] = 45 * i;
+ }
+ return arr;
+=======
+ public double getLevelValue(int level) {
+ if (level >= potAngles.length)
+ return potAngles[level];
+ else
+ return 0;
+>>>>>>> Fix some errors
+ }
+
+ /***
+ * This method sets the voltage of the arm motor. The range is from [-1,1]. A
+ * negative voltage makes the direction of the motor go backwards.
+ *
+ * @param speed
+ * The voltage that you set the motor at. The range of the voltage of
+ * the arm motor is from [-1,1]. A
+ * negative voltage makes the direction of the motor go backwards.
+ */
+
+ public void setArmSpeed(double speed) {
+ if (speed > 1)
+ speed = 1;
+ else if (speed < -1)
+ speed = -1;
+
+ defenseArm.set(speed);
+ }
+
+ /***
+ * This method sets the voltage of the hand motor. The range is from [-1,1]. A
+ * negative voltage makes the direction of the motor go backwards.
+ *
+ * @param speed
+ * The voltage that you set the motor at. The range of the voltage of
+ * the hand motor is from [-1,1]. A
+ * negative voltage makes the direction of the motor go backwards.
+ */
+
+ public void setHandSpeed(double speed) {
+ if (speed > 1)
+ speed = 1;
+ else if (speed < -1)
+ speed = -1;
+
+ defenseHand.set(speed);
+ }
+
+ // TODO: figure out if measurements are all in inches
+ public double getArmHorizontalDisplacement() {
+ double armHorizontalDisplacement = Constants.DefenseArm.ARM_LENGTH
+ * Math.cos(getArmPotAngle());
+ double handHorizontalDisplacement = Constants.DefenseArm.HAND_LENGTH
+ * Math.cos(getHandPotAngle());
+ return (armHorizontalDisplacement + handHorizontalDisplacement);
+ }
+
+ public double getArmVerticalDisplacement() {
+ double armMounted = Constants.DefenseArm.ARM_MOUNTED_HEIGHT;
+ double armVerticalDisplacement = Constants.DefenseArm.ARM_LENGTH
+ * Math.sin(getArmPotAngle());
+ double handVerticalDisplacement = Constants.DefenseArm.HAND_LENGTH
+ * Math.sin(getHandPotAngle());
+ return (armMounted + armVerticalDisplacement + handVerticalDisplacement);
+ }
+
+ public boolean isOutsideRange() {
+ if (getArmHorizontalDisplacement() < 15)
+ return false;
+ return true;
+ }
+
+ @Override
+ protected void initDefaultCommand() {
+ }
+}