Gamepad.java

// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
 
package org.wpilib.driverstation;
 
import java.util.EnumSet;
import java.util.Objects;
import org.wpilib.driverstation.GenericHID.HIDType;
import org.wpilib.driverstation.GenericHID.RumbleType;
import org.wpilib.driverstation.GenericHID.SupportedOutput;
import org.wpilib.driverstation.internal.DriverStationBackend;
import org.wpilib.event.BooleanEvent;
import org.wpilib.event.EventLoop;
import org.wpilib.math.util.MathUtil;
import org.wpilib.telemetry.TelemetryLoggable;
import org.wpilib.telemetry.TelemetryTable;
import org.wpilib.util.UsageReporting;

public class Gamepad implements HIDDevice, TelemetryLoggable {
  private static final double MAX_DEADBAND = Math.nextDown(1.0);

  public enum Button {
    FACE_DOWN(0, "FaceDownButton"),
    FACE_RIGHT(1, "FaceRightButton"),
    FACE_LEFT(2, "FaceLeftButton"),
    FACE_UP(3, "FaceUpButton"),
    BACK(4, "BackButton"),
    GUIDE(5, "GuideButton"),
    START(6, "StartButton"),
    LEFT_STICK(7, "LeftStickButton"),
    RIGHT_STICK(8, "RightStickButton"),
    LEFT_BUMPER(9, "LeftBumperButton"),
    RIGHT_BUMPER(10, "RightBumperButton"),
    DPAD_UP(11, "DpadUpButton"),
    DPAD_DOWN(12, "DpadDownButton"),
    DPAD_LEFT(13, "DpadLeftButton"),
    DPAD_RIGHT(14, "DpadRightButton"),
    MISC_1(15, "Misc1Button"),
    RIGHT_PADDLE_1(16, "RightPaddle1Button"),
    LEFT_PADDLE_1(17, "LeftPaddle1Button"),
    RIGHT_PADDLE_2(18, "RightPaddle2Button"),
    LEFT_PADDLE_2(19, "LeftPaddle2Button"),
    TOUCHPAD(20, "TouchpadButton"),
    MISC_2(21, "Misc2Button"),
    MISC_3(22, "Misc3Button"),
    MISC_4(23, "Misc4Button"),
    MISC_5(24, "Misc5Button"),
    MISC_6(25, "Misc6Button");

    public final int value;
 
    private final String m_name;
 
    Button(int value, String name) {
      this.value = value;
      this.m_name = name;
    }

    @Override
    public String toString() {
      return m_name;
    }
  }

  public enum Axis {
    LEFT_X(0, "LeftX"),
    LEFT_Y(1, "LeftY"),
    RIGHT_X(2, "RightX"),
    RIGHT_Y(3, "RightY"),
    LEFT_TRIGGER(4, "LeftTriggerAxis"),
    RIGHT_TRIGGER(5, "RightTriggerAxis");

    public final int value;
 
    private final String m_name;
 
    Axis(int value, String name) {
      this.value = value;
      this.m_name = name;
    }

    @Override
    public String toString() {
      return m_name;
    }
  }
 
  private double m_leftXDeadband = 0.1;
  private double m_leftYDeadband = 0.1;
  private double m_rightXDeadband = 0.1;
  private double m_rightYDeadband = 0.1;
  private double m_leftTriggerDeadband = 0.01;
  private double m_rightTriggerDeadband = 0.01;
 
  private static double clampDeadband(double deadband) {
    if (Double.isNaN(deadband)) {
      return 0.0;
    }
    return Math.clamp(deadband, 0.0, MAX_DEADBAND);
  }
 
  private final GenericHID m_hid;

  @Override
  public GenericHID getHID() {
    return m_hid;
  }

  public Gamepad(final int port) {
    this(DriverStation.getGenericHID(port));
  }

  public Gamepad(final GenericHID hid) {
    m_hid = Objects.requireNonNull(hid, "Provided HID object cannot be null");
    UsageReporting.reportUsage("HID", hid.getPort(), "Gamepad");
  }

  public void setLeftXDeadband(double deadband) {
    m_leftXDeadband = clampDeadband(deadband);
  }

  public void setLeftYDeadband(double deadband) {
    m_leftYDeadband = clampDeadband(deadband);
  }

  public void setRightXDeadband(double deadband) {
    m_rightXDeadband = clampDeadband(deadband);
  }

  public void setRightYDeadband(double deadband) {
    m_rightYDeadband = clampDeadband(deadband);
  }

  public void setLeftTriggerDeadband(double deadband) {
    m_leftTriggerDeadband = clampDeadband(deadband);
  }

  public void setRightTriggerDeadband(double deadband) {
    m_rightTriggerDeadband = clampDeadband(deadband);
  }

  public double getLeftX() {
    return MathUtil.applyDeadband(getAxis(Axis.LEFT_X), m_leftXDeadband);
  }

  public double getLeftY() {
    return MathUtil.applyDeadband(getAxis(Axis.LEFT_Y), m_leftYDeadband);
  }

  public double getRightX() {
    return MathUtil.applyDeadband(getAxis(Axis.RIGHT_X), m_rightXDeadband);
  }

  public double getRightY() {
    return MathUtil.applyDeadband(getAxis(Axis.RIGHT_Y), m_rightYDeadband);
  }

  public double getLeftTrigger() {
    return MathUtil.applyDeadband(getAxis(Axis.LEFT_TRIGGER), m_leftTriggerDeadband);
  }

  public BooleanEvent leftTrigger(double threshold, EventLoop loop) {
    return axisGreaterThan(Axis.LEFT_TRIGGER, threshold, loop);
  }

  public BooleanEvent leftTrigger(EventLoop loop) {
    return leftTrigger(0.5, loop);
  }

  public double getRightTrigger() {
    return MathUtil.applyDeadband(getAxis(Axis.RIGHT_TRIGGER), m_rightTriggerDeadband);
  }

  public BooleanEvent rightTrigger(double threshold, EventLoop loop) {
    return axisGreaterThan(Axis.RIGHT_TRIGGER, threshold, loop);
  }

  public BooleanEvent rightTrigger(EventLoop loop) {
    return rightTrigger(0.5, loop);
  }

  public boolean getFaceDownButton() {
    return getButton(Button.FACE_DOWN);
  }

  public boolean getFaceDownButtonPressed() {
    return getButtonPressed(Button.FACE_DOWN);
  }

  public boolean getFaceDownButtonReleased() {
    return getButtonReleased(Button.FACE_DOWN);
  }

  public BooleanEvent faceDown(EventLoop loop) {
    return button(Button.FACE_DOWN, loop);
  }

  public boolean getFaceRightButton() {
    return getButton(Button.FACE_RIGHT);
  }

  public boolean getFaceRightButtonPressed() {
    return getButtonPressed(Button.FACE_RIGHT);
  }

  public boolean getFaceRightButtonReleased() {
    return getButtonReleased(Button.FACE_RIGHT);
  }

  public BooleanEvent faceRight(EventLoop loop) {
    return button(Button.FACE_RIGHT, loop);
  }

  public boolean getFaceLeftButton() {
    return getButton(Button.FACE_LEFT);
  }

  public boolean getFaceLeftButtonPressed() {
    return getButtonPressed(Button.FACE_LEFT);
  }

  public boolean getFaceLeftButtonReleased() {
    return getButtonReleased(Button.FACE_LEFT);
  }

  public BooleanEvent faceLeft(EventLoop loop) {
    return button(Button.FACE_LEFT, loop);
  }

  public boolean getFaceUpButton() {
    return getButton(Button.FACE_UP);
  }

  public boolean getFaceUpButtonPressed() {
    return getButtonPressed(Button.FACE_UP);
  }

  public boolean getFaceUpButtonReleased() {
    return getButtonReleased(Button.FACE_UP);
  }

  public BooleanEvent faceUp(EventLoop loop) {
    return button(Button.FACE_UP, loop);
  }

  public boolean getBackButton() {
    return getButton(Button.BACK);
  }

  public boolean getBackButtonPressed() {
    return getButtonPressed(Button.BACK);
  }

  public boolean getBackButtonReleased() {
    return getButtonReleased(Button.BACK);
  }

  public BooleanEvent back(EventLoop loop) {
    return button(Button.BACK, loop);
  }

  public boolean getGuideButton() {
    return getButton(Button.GUIDE);
  }

  public boolean getGuideButtonPressed() {
    return getButtonPressed(Button.GUIDE);
  }

  public boolean getGuideButtonReleased() {
    return getButtonReleased(Button.GUIDE);
  }

  public BooleanEvent guide(EventLoop loop) {
    return button(Button.GUIDE, loop);
  }

  public boolean getStartButton() {
    return getButton(Button.START);
  }

  public boolean getStartButtonPressed() {
    return getButtonPressed(Button.START);
  }

  public boolean getStartButtonReleased() {
    return getButtonReleased(Button.START);
  }

  public BooleanEvent start(EventLoop loop) {
    return button(Button.START, loop);
  }

  public boolean getLeftStickButton() {
    return getButton(Button.LEFT_STICK);
  }

  public boolean getLeftStickButtonPressed() {
    return getButtonPressed(Button.LEFT_STICK);
  }

  public boolean getLeftStickButtonReleased() {
    return getButtonReleased(Button.LEFT_STICK);
  }

  public BooleanEvent leftStick(EventLoop loop) {
    return button(Button.LEFT_STICK, loop);
  }

  public boolean getRightStickButton() {
    return getButton(Button.RIGHT_STICK);
  }

  public boolean getRightStickButtonPressed() {
    return getButtonPressed(Button.RIGHT_STICK);
  }

  public boolean getRightStickButtonReleased() {
    return getButtonReleased(Button.RIGHT_STICK);
  }

  public BooleanEvent rightStick(EventLoop loop) {
    return button(Button.RIGHT_STICK, loop);
  }

  public boolean getLeftBumperButton() {
    return getButton(Button.LEFT_BUMPER);
  }

  public boolean getLeftBumperButtonPressed() {
    return getButtonPressed(Button.LEFT_BUMPER);
  }

  public boolean getLeftBumperButtonReleased() {
    return getButtonReleased(Button.LEFT_BUMPER);
  }

  public BooleanEvent leftBumper(EventLoop loop) {
    return button(Button.LEFT_BUMPER, loop);
  }

  public boolean getRightBumperButton() {
    return getButton(Button.RIGHT_BUMPER);
  }

  public boolean getRightBumperButtonPressed() {
    return getButtonPressed(Button.RIGHT_BUMPER);
  }

  public boolean getRightBumperButtonReleased() {
    return getButtonReleased(Button.RIGHT_BUMPER);
  }

  public BooleanEvent rightBumper(EventLoop loop) {
    return button(Button.RIGHT_BUMPER, loop);
  }

  public boolean getDpadUpButton() {
    return getButton(Button.DPAD_UP);
  }

  public boolean getDpadUpButtonPressed() {
    return getButtonPressed(Button.DPAD_UP);
  }

  public boolean getDpadUpButtonReleased() {
    return getButtonReleased(Button.DPAD_UP);
  }

  public BooleanEvent dpadUp(EventLoop loop) {
    return button(Button.DPAD_UP, loop);
  }

  public boolean getDpadDownButton() {
    return getButton(Button.DPAD_DOWN);
  }

  public boolean getDpadDownButtonPressed() {
    return getButtonPressed(Button.DPAD_DOWN);
  }

  public boolean getDpadDownButtonReleased() {
    return getButtonReleased(Button.DPAD_DOWN);
  }

  public BooleanEvent dpadDown(EventLoop loop) {
    return button(Button.DPAD_DOWN, loop);
  }

  public boolean getDpadLeftButton() {
    return getButton(Button.DPAD_LEFT);
  }

  public boolean getDpadLeftButtonPressed() {
    return getButtonPressed(Button.DPAD_LEFT);
  }

  public boolean getDpadLeftButtonReleased() {
    return getButtonReleased(Button.DPAD_LEFT);
  }

  public BooleanEvent dpadLeft(EventLoop loop) {
    return button(Button.DPAD_LEFT, loop);
  }

  public boolean getDpadRightButton() {
    return getButton(Button.DPAD_RIGHT);
  }

  public boolean getDpadRightButtonPressed() {
    return getButtonPressed(Button.DPAD_RIGHT);
  }

  public boolean getDpadRightButtonReleased() {
    return getButtonReleased(Button.DPAD_RIGHT);
  }

  public BooleanEvent dpadRight(EventLoop loop) {
    return button(Button.DPAD_RIGHT, loop);
  }

  public boolean getMisc1Button() {
    return getButton(Button.MISC_1);
  }

  public boolean getMisc1ButtonPressed() {
    return getButtonPressed(Button.MISC_1);
  }

  public boolean getMisc1ButtonReleased() {
    return getButtonReleased(Button.MISC_1);
  }

  public BooleanEvent misc1(EventLoop loop) {
    return button(Button.MISC_1, loop);
  }

  public boolean getRightPaddle1Button() {
    return getButton(Button.RIGHT_PADDLE_1);
  }

  public boolean getRightPaddle1ButtonPressed() {
    return getButtonPressed(Button.RIGHT_PADDLE_1);
  }

  public boolean getRightPaddle1ButtonReleased() {
    return getButtonReleased(Button.RIGHT_PADDLE_1);
  }

  public BooleanEvent rightPaddle1(EventLoop loop) {
    return button(Button.RIGHT_PADDLE_1, loop);
  }

  public boolean getLeftPaddle1Button() {
    return getButton(Button.LEFT_PADDLE_1);
  }

  public boolean getLeftPaddle1ButtonPressed() {
    return getButtonPressed(Button.LEFT_PADDLE_1);
  }

  public boolean getLeftPaddle1ButtonReleased() {
    return getButtonReleased(Button.LEFT_PADDLE_1);
  }

  public BooleanEvent leftPaddle1(EventLoop loop) {
    return button(Button.LEFT_PADDLE_1, loop);
  }

  public boolean getRightPaddle2Button() {
    return getButton(Button.RIGHT_PADDLE_2);
  }

  public boolean getRightPaddle2ButtonPressed() {
    return getButtonPressed(Button.RIGHT_PADDLE_2);
  }

  public boolean getRightPaddle2ButtonReleased() {
    return getButtonReleased(Button.RIGHT_PADDLE_2);
  }

  public BooleanEvent rightPaddle2(EventLoop loop) {
    return button(Button.RIGHT_PADDLE_2, loop);
  }

  public boolean getLeftPaddle2Button() {
    return getButton(Button.LEFT_PADDLE_2);
  }

  public boolean getLeftPaddle2ButtonPressed() {
    return getButtonPressed(Button.LEFT_PADDLE_2);
  }

  public boolean getLeftPaddle2ButtonReleased() {
    return getButtonReleased(Button.LEFT_PADDLE_2);
  }

  public BooleanEvent leftPaddle2(EventLoop loop) {
    return button(Button.LEFT_PADDLE_2, loop);
  }

  public boolean getTouchpadButton() {
    return getButton(Button.TOUCHPAD);
  }

  public boolean getTouchpadButtonPressed() {
    return getButtonPressed(Button.TOUCHPAD);
  }

  public boolean getTouchpadButtonReleased() {
    return getButtonReleased(Button.TOUCHPAD);
  }

  public BooleanEvent touchpad(EventLoop loop) {
    return button(Button.TOUCHPAD, loop);
  }

  public boolean getMisc2Button() {
    return getButton(Button.MISC_2);
  }

  public boolean getMisc2ButtonPressed() {
    return getButtonPressed(Button.MISC_2);
  }

  public boolean getMisc2ButtonReleased() {
    return getButtonReleased(Button.MISC_2);
  }

  public BooleanEvent misc2(EventLoop loop) {
    return button(Button.MISC_2, loop);
  }

  public boolean getMisc3Button() {
    return getButton(Button.MISC_3);
  }

  public boolean getMisc3ButtonPressed() {
    return getButtonPressed(Button.MISC_3);
  }

  public boolean getMisc3ButtonReleased() {
    return getButtonReleased(Button.MISC_3);
  }

  public BooleanEvent misc3(EventLoop loop) {
    return button(Button.MISC_3, loop);
  }

  public boolean getMisc4Button() {
    return getButton(Button.MISC_4);
  }

  public boolean getMisc4ButtonPressed() {
    return getButtonPressed(Button.MISC_4);
  }

  public boolean getMisc4ButtonReleased() {
    return getButtonReleased(Button.MISC_4);
  }

  public BooleanEvent misc4(EventLoop loop) {
    return button(Button.MISC_4, loop);
  }

  public boolean getMisc5Button() {
    return getButton(Button.MISC_5);
  }

  public boolean getMisc5ButtonPressed() {
    return getButtonPressed(Button.MISC_5);
  }

  public boolean getMisc5ButtonReleased() {
    return getButtonReleased(Button.MISC_5);
  }

  public BooleanEvent misc5(EventLoop loop) {
    return button(Button.MISC_5, loop);
  }

  public boolean getMisc6Button() {
    return getButton(Button.MISC_6);
  }

  public boolean getMisc6ButtonPressed() {
    return getButtonPressed(Button.MISC_6);
  }

  public boolean getMisc6ButtonReleased() {
    return getButtonReleased(Button.MISC_6);
  }

  public BooleanEvent misc6(EventLoop loop) {
    return button(Button.MISC_6, loop);
  }

  public boolean getButton(Button button) {
    return m_hid.getRawButton(button.value);
  }

  public boolean getButtonPressed(Button button) {
    return m_hid.getRawButtonPressed(button.value);
  }

  public boolean getButtonReleased(Button button) {
    return m_hid.getRawButtonReleased(button.value);
  }

  public BooleanEvent button(Button button, EventLoop loop) {
    return m_hid.button(button.value, loop);
  }

  public double getAxis(Axis axis) {
    return m_hid.getRawAxis(axis.value);
  }

  public BooleanEvent axisLessThan(Axis axis, double threshold, EventLoop loop) {
    return m_hid.axisLessThan(axis.value, threshold, loop);
  }

  public BooleanEvent axisGreaterThan(Axis axis, double threshold, EventLoop loop) {
    return m_hid.axisGreaterThan(axis.value, threshold, loop);
  }

  public int getAxesAvailable() {
    return m_hid.getAxesAvailable();
  }

  public long getButtonsAvailable() {
    return m_hid.getButtonsAvailable();
  }

  public boolean isConnected() {
    return m_hid.isConnected();
  }

  public HIDType getGamepadType() {
    return m_hid.getGamepadType();
  }

  public EnumSet<SupportedOutput> getSupportedOutputs() {
    return m_hid.getSupportedOutputs();
  }

  public String getName() {
    return m_hid.getName();
  }

  public void setLeds(int r, int g, int b) {
    m_hid.setLeds(r, g, b);
  }

  public void setRumble(RumbleType type, double value) {
    m_hid.setRumble(type, value);
  }

  public boolean getTouchpadFingerAvailable(int touchpad, int finger) {
    return m_hid.getTouchpadFingerAvailable(touchpad, finger);
  }

  public TouchpadFinger getTouchpadFinger(int touchpad, int finger) {
    return m_hid.getTouchpadFinger(touchpad, finger);
  }
 
  private double getAxisForTelemetry(Axis axis) {
    return DriverStationBackend.getStickAxisIfAvailable(m_hid.getPort(), axis.value).orElse(0.0);
  }
 
  @Override
  public void logTo(TelemetryTable table) {
    table.log("LeftTrigger", getAxisForTelemetry(Axis.LEFT_TRIGGER));
    table.log("RightTrigger", getAxisForTelemetry(Axis.RIGHT_TRIGGER));
    table.log("LeftX", getAxisForTelemetry(Axis.LEFT_X));
    table.log("LeftY", getAxisForTelemetry(Axis.LEFT_Y));
    table.log("RightX", getAxisForTelemetry(Axis.RIGHT_X));
    table.log("RightY", getAxisForTelemetry(Axis.RIGHT_Y));
 
    long buttons = DriverStationBackend.getStickButtons(m_hid.getPort());
    table.log("FaceDown", (buttons & (1L << Button.FACE_DOWN.value)) != 0);
    table.log("FaceRight", (buttons & (1L << Button.FACE_RIGHT.value)) != 0);
    table.log("FaceLeft", (buttons & (1L << Button.FACE_LEFT.value)) != 0);
    table.log("FaceUp", (buttons & (1L << Button.FACE_UP.value)) != 0);
    table.log("Back", (buttons & (1L << Button.BACK.value)) != 0);
    table.log("Guide", (buttons & (1L << Button.GUIDE.value)) != 0);
    table.log("Start", (buttons & (1L << Button.START.value)) != 0);
    table.log("LeftStick", (buttons & (1L << Button.LEFT_STICK.value)) != 0);
    table.log("RightStick", (buttons & (1L << Button.RIGHT_STICK.value)) != 0);
    table.log("LeftBumper", (buttons & (1L << Button.LEFT_BUMPER.value)) != 0);
    table.log("RightBumper", (buttons & (1L << Button.RIGHT_BUMPER.value)) != 0);
    table.log("DpadUp", (buttons & (1L << Button.DPAD_UP.value)) != 0);
    table.log("DpadDown", (buttons & (1L << Button.DPAD_DOWN.value)) != 0);
    table.log("DpadLeft", (buttons & (1L << Button.DPAD_LEFT.value)) != 0);
    table.log("DpadRight", (buttons & (1L << Button.DPAD_RIGHT.value)) != 0);
    table.log("Misc1", (buttons & (1L << Button.MISC_1.value)) != 0);
    table.log("RightPaddle1", (buttons & (1L << Button.RIGHT_PADDLE_1.value)) != 0);
    table.log("LeftPaddle1", (buttons & (1L << Button.LEFT_PADDLE_1.value)) != 0);
    table.log("RightPaddle2", (buttons & (1L << Button.RIGHT_PADDLE_2.value)) != 0);
    table.log("LeftPaddle2", (buttons & (1L << Button.LEFT_PADDLE_2.value)) != 0);
    table.log("Touchpad", (buttons & (1L << Button.TOUCHPAD.value)) != 0);
    table.log("Misc2", (buttons & (1L << Button.MISC_2.value)) != 0);
    table.log("Misc3", (buttons & (1L << Button.MISC_3.value)) != 0);
    table.log("Misc4", (buttons & (1L << Button.MISC_4.value)) != 0);
    table.log("Misc5", (buttons & (1L << Button.MISC_5.value)) != 0);
    table.log("Misc6", (buttons & (1L << Button.MISC_6.value)) != 0);
  }
 
  @Override
  public String getTelemetryType() {
    return "HID:Gamepad";
  }
}