[wpilib, hal] High Level REV PH changes (#3792)

More functionality was implemented at the HAL level, so expose that to the wpilib level.

This also does units changes for all the PH related functionality.

hal/src/main/java/edu/wpi/first/hal/REVPHFaults.java

@@ -0,0 +1,104 @@
+// 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 edu.wpi.first.hal;
+
+@SuppressWarnings("AbbreviationAsWordInName")
+public class REVPHFaults {
+  @SuppressWarnings("MemberName")
+  public final boolean Channel0Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel1Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel2Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel3Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel4Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel5Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel6Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel7Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel8Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel9Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel10Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel11Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel12Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel13Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel14Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Channel15Fault;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CompressorOverCurrent;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CompressorOpen;
+
+  @SuppressWarnings("MemberName")
+  public final boolean SolenoidOverCurrent;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Brownout;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CanWarning;
+
+  @SuppressWarnings("MemberName")
+  public final boolean HardwareFault;
+
+  /**
+   * Called from HAL to construct.
+   *
+   * @param faults the fault bitfields
+   */
+  public REVPHFaults(int faults) {
+    Channel0Fault = (faults & 0x1) != 0;
+    Channel1Fault = (faults & 0x2) != 0;
+    Channel2Fault = (faults & 0x4) != 0;
+    Channel3Fault = (faults & 0x8) != 0;
+    Channel4Fault = (faults & 0x10) != 0;
+    Channel5Fault = (faults & 0x20) != 0;
+    Channel6Fault = (faults & 0x40) != 0;
+    Channel7Fault = (faults & 0x80) != 0;
+    Channel8Fault = (faults & 0x100) != 0;
+    Channel9Fault = (faults & 0x200) != 0;
+    Channel10Fault = (faults & 0x400) != 0;
+    Channel11Fault = (faults & 0x800) != 0;
+    Channel12Fault = (faults & 0x1000) != 0;
+    Channel13Fault = (faults & 0x2000) != 0;
+    Channel14Fault = (faults & 0x4000) != 0;
+    Channel15Fault = (faults & 0x8000) != 0;
+    CompressorOverCurrent = (faults & 0x8000) != 0;
+    CompressorOpen = (faults & 0x10000) != 0;
+    SolenoidOverCurrent = (faults & 0x20000) != 0;
+    Brownout = (faults & 0x40000) != 0;
+    CanWarning = (faults & 0x80000) != 0;
+    HardwareFault = (faults & 0x100000) != 0;
+  }
+}

hal/src/main/java/edu/wpi/first/hal/REVPHJNI.java

@@ -40,7 +40,7 @@ public class REVPHJNI extends JNIWrapper {
 
   public static native boolean getPressureSwitch(int handle);
 
-  public static native double getAnalogPressure(int handle, int channel);
+  public static native double getAnalogVoltage(int handle, int channel);
 
   public static native double getCompressorCurrent(int handle);
 
@@ -49,4 +49,28 @@ public class REVPHJNI extends JNIWrapper {
   public static native void setSolenoids(int handle, int mask, int values);
 
   public static native void fireOneShot(int handle, int index, int durMs);
+
+  public static native void clearStickyFaults(int handle);
+
+  public static native double getInputVoltage(int handle);
+
+  public static native double get5VVoltage(int handle);
+
+  public static native double getSolenoidCurrent(int handle);
+
+  public static native double getSolenoidVoltage(int handle);
+
+  public static native int getStickyFaultsNative(int handle);
+
+  public static REVPHStickyFaults getStickyFaults(int handle) {
+    return new REVPHStickyFaults(getStickyFaultsNative(handle));
+  }
+
+  public static native int getFaultsNative(int handle);
+
+  public static REVPHFaults getFaults(int handle) {
+    return new REVPHFaults(getFaultsNative(handle));
+  }
+
+  public static native REVPHVersion getVersion(int handle);
 }

hal/src/main/java/edu/wpi/first/hal/REVPHStickyFaults.java

@@ -0,0 +1,44 @@
+// 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 edu.wpi.first.hal;
+
+@SuppressWarnings("AbbreviationAsWordInName")
+public class REVPHStickyFaults {
+  @SuppressWarnings("MemberName")
+  public final boolean CompressorOverCurrent;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CompressorOpen;
+
+  @SuppressWarnings("MemberName")
+  public final boolean SolenoidOverCurrent;
+
+  @SuppressWarnings("MemberName")
+  public final boolean Brownout;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CanWarning;
+
+  @SuppressWarnings("MemberName")
+  public final boolean CanBusOff;
+
+  @SuppressWarnings("MemberName")
+  public final boolean HasReset;
+
+  /**
+   * Called from HAL.
+   *
+   * @param faults sticky fault bit mask
+   */
+  public REVPHStickyFaults(int faults) {
+    CompressorOverCurrent = (faults & 0x1) != 0;
+    CompressorOpen = (faults & 0x2) != 0;
+    SolenoidOverCurrent = (faults & 0x4) != 0;
+    Brownout = (faults & 0x8) != 0;
+    CanWarning = (faults & 0x10) != 0;
+    CanBusOff = (faults & 0x20) != 0;
+    HasReset = (faults & 0x40) != 0;
+  }
+}

hal/src/main/java/edu/wpi/first/hal/REVPHVersion.java

@@ -0,0 +1,51 @@
+// 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 edu.wpi.first.hal;
+
+@SuppressWarnings("AbbreviationAsWordInName")
+public class REVPHVersion {
+  @SuppressWarnings("MemberName")
+  public final int firmwareMajor;
+
+  @SuppressWarnings("MemberName")
+  public final int firmwareMinor;
+
+  @SuppressWarnings("MemberName")
+  public final int firmwareFix;
+
+  @SuppressWarnings("MemberName")
+  public final int hardwareMinor;
+
+  @SuppressWarnings("MemberName")
+  public final int hardwareMajor;
+
+  @SuppressWarnings("MemberName")
+  public final int uniqueId;
+
+  /**
+   * Constructs a revph version (Called from the HAL).
+   *
+   * @param firmwareMajor firmware major
+   * @param firmwareMinor firmware minor
+   * @param firmwareFix firmware fix
+   * @param hardwareMinor hardware minor
+   * @param hardwareMajor hardware major
+   * @param uniqueId unique id
+   */
+  public REVPHVersion(
+      int firmwareMajor,
+      int firmwareMinor,
+      int firmwareFix,
+      int hardwareMinor,
+      int hardwareMajor,
+      int uniqueId) {
+    this.firmwareMajor = firmwareMajor;
+    this.firmwareMinor = firmwareMinor;
+    this.firmwareFix = firmwareFix;
+    this.hardwareMinor = hardwareMinor;
+    this.hardwareMajor = hardwareMajor;
+    this.uniqueId = uniqueId;
+  }
+}

hal/src/main/native/athena/REVPH.cpp

@@ -376,8 +376,8 @@ double HAL_GetREVPHCompressorCurrent(HAL_REVPHHandle handle, int32_t* status) {
   return PH_status_1_compressor_current_decode(status1.compressor_current);
 }
 
-double HAL_GetREVPHAnalogPressure(HAL_REVPHHandle handle, int32_t channel,
-                                  int32_t* status) {
+double HAL_GetREVPHAnalogVoltage(HAL_REVPHHandle handle, int32_t channel,
+                                 int32_t* status) {
   auto ph = REVPHHandles->Get(handle);
   if (ph == nullptr) {
     *status = HAL_HANDLE_ERROR;
@@ -467,9 +467,9 @@ double HAL_GetREVPHSolenoidVoltage(HAL_REVPHHandle handle, int32_t* status) {
   return PH_status_1_solenoid_voltage_decode(status1.solenoid_voltage);
 }
 
-HAL_REVPHVersion HAL_GetREVPHVersion(HAL_REVPHHandle handle, int32_t* status) {
-  HAL_REVPHVersion version;
-  std::memset(&version, 0, sizeof(version));
+void HAL_GetREVPHVersion(HAL_REVPHHandle handle, HAL_REVPHVersion* version,
+                         int32_t* status) {
+  std::memset(version, 0, sizeof(*version));
   uint8_t packedData[8] = {0};
   int32_t length = 0;
   uint64_t timestamp = 0;
@@ -477,33 +477,31 @@ HAL_REVPHVersion HAL_GetREVPHVersion(HAL_REVPHHandle handle, int32_t* status) {
   auto ph = REVPHHandles->Get(handle);
   if (ph == nullptr) {
     *status = HAL_HANDLE_ERROR;
-    return version;
+    return;
   }
 
   HAL_WriteCANRTRFrame(ph->hcan, PH_VERSION_LENGTH, PH_VERSION_FRAME_API,
                        status);
 
   if (*status != 0) {
-    return version;
+    return;
   }
 
   HAL_ReadCANPacketTimeout(ph->hcan, PH_VERSION_FRAME_API, packedData, &length,
                            &timestamp, kDefaultControlPeriod * 2, status);
 
   if (*status != 0) {
-    return version;
+    return;
   }
 
   PH_version_unpack(&result, packedData, PH_VERSION_LENGTH);
 
-  version.firmwareMajor = result.firmware_year;
-  version.firmwareMinor = result.firmware_minor;
-  version.firmwareFix = result.firmware_fix;
-  version.hardwareMinor = result.hardware_minor;
-  version.hardwareMajor = result.hardware_major;
-  version.uniqueId = result.unique_id;
-
-  return version;
+  version->firmwareMajor = result.firmware_year;
+  version->firmwareMinor = result.firmware_minor;
+  version->firmwareFix = result.firmware_fix;
+  version->hardwareMinor = result.hardware_minor;
+  version->hardwareMajor = result.hardware_major;
+  version->uniqueId = result.unique_id;
 }
 
 int32_t HAL_GetREVPHSolenoids(HAL_REVPHHandle handle, int32_t* status) {
@@ -660,60 +658,58 @@ void HAL_FireREVPHOneShot(HAL_REVPHHandle handle, int32_t index, int32_t durMs,
                      PH_PULSE_ONCE_FRAME_API, status);
 }
 
-HAL_REVPHFaults HAL_GetREVPHFaults(HAL_REVPHHandle handle, int32_t* status) {
-  HAL_REVPHFaults faults = {};
+void HAL_GetREVPHFaults(HAL_REVPHHandle handle, HAL_REVPHFaults* faults,
+                        int32_t* status) {
+  std::memset(faults, 0, sizeof(*faults));
   auto ph = REVPHHandles->Get(handle);
   if (ph == nullptr) {
     *status = HAL_HANDLE_ERROR;
-    return faults;
+    return;
   }
 
   PH_status_0_t status0 = HAL_ReadREVPHStatus0(ph->hcan, status);
-  faults.channel0Fault = status0.channel_0_fault;
-  faults.channel1Fault = status0.channel_1_fault;
-  faults.channel2Fault = status0.channel_2_fault;
-  faults.channel3Fault = status0.channel_3_fault;
-  faults.channel4Fault = status0.channel_4_fault;
-  faults.channel5Fault = status0.channel_5_fault;
-  faults.channel6Fault = status0.channel_6_fault;
-  faults.channel7Fault = status0.channel_7_fault;
-  faults.channel8Fault = status0.channel_8_fault;
-  faults.channel9Fault = status0.channel_9_fault;
-  faults.channel10Fault = status0.channel_10_fault;
-  faults.channel11Fault = status0.channel_11_fault;
-  faults.channel12Fault = status0.channel_12_fault;
-  faults.channel13Fault = status0.channel_13_fault;
-  faults.channel14Fault = status0.channel_14_fault;
-  faults.channel15Fault = status0.channel_15_fault;
-  faults.compressorOverCurrent = status0.compressor_oc_fault;
-  faults.compressorOpen = status0.compressor_open_fault;
-  faults.solenoidOverCurrent = status0.solenoid_oc_fault;
-  faults.brownout = status0.brownout_fault;
-  faults.canWarning = status0.can_warning_fault;
-  faults.hardwareFault = status0.hardware_fault;
-
-  return faults;
+  faults->channel0Fault = status0.channel_0_fault;
+  faults->channel1Fault = status0.channel_1_fault;
+  faults->channel2Fault = status0.channel_2_fault;
+  faults->channel3Fault = status0.channel_3_fault;
+  faults->channel4Fault = status0.channel_4_fault;
+  faults->channel5Fault = status0.channel_5_fault;
+  faults->channel6Fault = status0.channel_6_fault;
+  faults->channel7Fault = status0.channel_7_fault;
+  faults->channel8Fault = status0.channel_8_fault;
+  faults->channel9Fault = status0.channel_9_fault;
+  faults->channel10Fault = status0.channel_10_fault;
+  faults->channel11Fault = status0.channel_11_fault;
+  faults->channel12Fault = status0.channel_12_fault;
+  faults->channel13Fault = status0.channel_13_fault;
+  faults->channel14Fault = status0.channel_14_fault;
+  faults->channel15Fault = status0.channel_15_fault;
+  faults->compressorOverCurrent = status0.compressor_oc_fault;
+  faults->compressorOpen = status0.compressor_open_fault;
+  faults->solenoidOverCurrent = status0.solenoid_oc_fault;
+  faults->brownout = status0.brownout_fault;
+  faults->canWarning = status0.can_warning_fault;
+  faults->hardwareFault = status0.hardware_fault;
 }
 
-HAL_REVPHStickyFaults HAL_GetREVPHStickyFaults(HAL_REVPHHandle handle,
-                                               int32_t* status) {
-  HAL_REVPHStickyFaults stickyFaults = {};
+void HAL_GetREVPHStickyFaults(HAL_REVPHHandle handle,
+                              HAL_REVPHStickyFaults* stickyFaults,
+                              int32_t* status) {
+  std::memset(stickyFaults, 0, sizeof(*stickyFaults));
   auto ph = REVPHHandles->Get(handle);
   if (ph == nullptr) {
     *status = HAL_HANDLE_ERROR;
-    return stickyFaults;
+    return;
   }
 
   PH_status_1_t status1 = HAL_ReadREVPHStatus1(ph->hcan, status);
-  stickyFaults.compressorOverCurrent = status1.sticky_compressor_oc_fault;
-  stickyFaults.compressorOpen = status1.sticky_compressor_open_fault;
-  stickyFaults.solenoidOverCurrent = status1.sticky_solenoid_oc_fault;
-  stickyFaults.brownout = status1.sticky_brownout_fault;
-  stickyFaults.canWarning = status1.sticky_can_warning_fault;
-  stickyFaults.canBusOff = status1.sticky_can_bus_off_fault;
-  stickyFaults.hasReset = status1.sticky_has_reset_fault;
-
-  return stickyFaults;
+  stickyFaults->compressorOverCurrent = status1.sticky_compressor_oc_fault;
+  stickyFaults->compressorOpen = status1.sticky_compressor_open_fault;
+  stickyFaults->solenoidOverCurrent = status1.sticky_solenoid_oc_fault;
+  stickyFaults->brownout = status1.sticky_brownout_fault;
+  stickyFaults->canWarning = status1.sticky_can_warning_fault;
+  stickyFaults->canBusOff = status1.sticky_can_bus_off_fault;
+  stickyFaults->hasReset = status1.sticky_has_reset_fault;
 }
 
 void HAL_ClearREVPHStickyFaults(HAL_REVPHHandle handle, int32_t* status) {

hal/src/main/native/cpp/jni/HALUtil.cpp

@@ -53,6 +53,7 @@ static JClass accumulatorResultCls;
 static JClass canDataCls;
 static JClass halValueCls;
 static JClass baseStoreCls;
+static JClass revPHVersionCls;
 
 static const JClassInit classes[] = {
     {"edu/wpi/first/hal/PWMConfigDataResult", &pwmConfigDataResultCls},
@@ -61,7 +62,8 @@ static const JClassInit classes[] = {
     {"edu/wpi/first/hal/AccumulatorResult", &accumulatorResultCls},
     {"edu/wpi/first/hal/CANData", &canDataCls},
     {"edu/wpi/first/hal/HALValue", &halValueCls},
-    {"edu/wpi/first/hal/DMAJNISample$BaseStore", &baseStoreCls}};
+    {"edu/wpi/first/hal/DMAJNISample$BaseStore", &baseStoreCls},
+    {"edu/wpi/first/hal/REVPHVersion", &revPHVersionCls}};
 
 static const JExceptionInit exceptions[] = {
     {"java/lang/IllegalArgumentException", &illegalArgExCls},
@@ -238,6 +240,19 @@ jobject CreatePWMConfigDataResult(JNIEnv* env, int32_t maxPwm,
       static_cast<jint>(deadbandMinPwm), static_cast<jint>(minPwm));
 }
 
+jobject CreateREVPHVersion(JNIEnv* env, uint32_t firmwareMajor,
+                           uint32_t firmwareMinor, uint32_t firmwareFix,
+                           uint32_t hardwareMinor, uint32_t hardwareMajor,
+                           uint32_t uniqueId) {
+  static jmethodID constructor =
+      env->GetMethodID(revPHVersionCls, "<init>", "(IIIIII)V");
+  return env->NewObject(
+      revPHVersionCls, constructor, static_cast<jint>(firmwareMajor),
+      static_cast<jint>(firmwareMinor), static_cast<jint>(firmwareFix),
+      static_cast<jint>(hardwareMinor), static_cast<jint>(hardwareMajor),
+      static_cast<jint>(uniqueId));
+}
+
 void SetCanStatusObject(JNIEnv* env, jobject canStatus,
                         float percentBusUtilization, uint32_t busOffCount,
                         uint32_t txFullCount, uint32_t receiveErrorCount,

hal/src/main/native/cpp/jni/HALUtil.h

@@ -59,6 +59,11 @@ jobject CreatePWMConfigDataResult(JNIEnv* env, int32_t maxPwm,
                                   int32_t deadbandMaxPwm, int32_t centerPwm,
                                   int32_t deadbandMinPwm, int32_t minPwm);
 
+jobject CreateREVPHVersion(JNIEnv* env, uint32_t firmwareMajor,
+                           uint32_t firmwareMinor, uint32_t firmwareFix,
+                           uint32_t hardwareMinor, uint32_t hardwareMajor,
+                           uint32_t uniqueId);
+
 void SetCanStatusObject(JNIEnv* env, jobject canStatus,
                         float percentBusUtilization, uint32_t busOffCount,
                         uint32_t txFullCount, uint32_t receiveErrorCount,

hal/src/main/native/cpp/jni/REVPHJNI.cpp

@@ -196,15 +196,15 @@ Java_edu_wpi_first_hal_REVPHJNI_getPressureSwitch
 
 /*
  * Class:     edu_wpi_first_hal_REVPHJNI
- * Method:    getAnalogPressure
+ * Method:    getAnalogVoltage
  * Signature: (II)D
  */
 JNIEXPORT jdouble JNICALL
-Java_edu_wpi_first_hal_REVPHJNI_getAnalogPressure
+Java_edu_wpi_first_hal_REVPHJNI_getAnalogVoltage
   (JNIEnv* env, jclass, jint handle, jint channel)
 {
   int32_t status = 0;
-  auto result = HAL_GetREVPHAnalogPressure(handle, channel, &status);
+  auto result = HAL_GetREVPHAnalogVoltage(handle, channel, &status);
   CheckStatus(env, status, false);
   return result;
 }
@@ -267,4 +267,137 @@ Java_edu_wpi_first_hal_REVPHJNI_fireOneShot
   CheckStatus(env, status, false);
 }
 
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    clearStickyFaults
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_clearStickyFaults
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  HAL_ClearREVPHStickyFaults(handle, &status);
+  CheckStatus(env, status, false);
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getInputVoltage
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getInputVoltage
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  auto voltage = HAL_GetREVPHVoltage(handle, &status);
+  CheckStatus(env, status, false);
+  return voltage;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    get5VVoltage
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_get5VVoltage
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  auto voltage = HAL_GetREVPH5VVoltage(handle, &status);
+  CheckStatus(env, status, false);
+  return voltage;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getSolenoidCurrent
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getSolenoidCurrent
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  auto voltage = HAL_GetREVPHSolenoidCurrent(handle, &status);
+  CheckStatus(env, status, false);
+  return voltage;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getSolenoidVoltage
+ * Signature: (I)D
+ */
+JNIEXPORT jdouble JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getSolenoidVoltage
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  auto voltage = HAL_GetREVPHSolenoidVoltage(handle, &status);
+  CheckStatus(env, status, false);
+  return voltage;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getStickyFaultsNative
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getStickyFaultsNative
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  HAL_REVPHStickyFaults halFaults;
+  std::memset(&halFaults, 0, sizeof(halFaults));
+  HAL_GetREVPHStickyFaults(handle, &halFaults, &status);
+  CheckStatus(env, status, false);
+  jint faults;
+  static_assert(sizeof(faults) == sizeof(halFaults));
+  std::memcpy(&faults, &halFaults, sizeof(faults));
+  return faults;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getFaultsNative
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getFaultsNative
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  HAL_REVPHFaults halFaults;
+  std::memset(&halFaults, 0, sizeof(halFaults));
+  HAL_GetREVPHFaults(handle, &halFaults, &status);
+  CheckStatus(env, status, false);
+  jint faults;
+  static_assert(sizeof(faults) == sizeof(halFaults));
+  std::memcpy(&faults, &halFaults, sizeof(faults));
+  return faults;
+}
+
+/*
+ * Class:     edu_wpi_first_hal_REVPHJNI
+ * Method:    getVersion
+ * Signature: (I)Ljava/lang/Object;
+ */
+JNIEXPORT jobject JNICALL
+Java_edu_wpi_first_hal_REVPHJNI_getVersion
+  (JNIEnv* env, jclass, jint handle)
+{
+  int32_t status = 0;
+  HAL_REVPHVersion version;
+  std::memset(&version, 0, sizeof(version));
+  HAL_GetREVPHVersion(handle, &version, &status);
+  CheckStatus(env, status, false);
+  return CreateREVPHVersion(env, version.firmwareMajor, version.firmwareMinor,
+                            version.firmwareFix, version.hardwareMinor,
+                            version.hardwareMajor, version.uniqueId);
+}
+
 }  // extern "C"

hal/src/main/native/include/hal/REVPH.h

@@ -120,13 +120,14 @@ HAL_REVPHCompressorConfigType HAL_GetREVPHCompressorConfig(
     HAL_REVPHHandle handle, int32_t* status);
 HAL_Bool HAL_GetREVPHPressureSwitch(HAL_REVPHHandle handle, int32_t* status);
 double HAL_GetREVPHCompressorCurrent(HAL_REVPHHandle handle, int32_t* status);
-double HAL_GetREVPHAnalogPressure(HAL_REVPHHandle handle, int32_t channel,
-                                  int32_t* status);
+double HAL_GetREVPHAnalogVoltage(HAL_REVPHHandle handle, int32_t channel,
+                                 int32_t* status);
 double HAL_GetREVPHVoltage(HAL_REVPHHandle handle, int32_t* status);
 double HAL_GetREVPH5VVoltage(HAL_REVPHHandle handle, int32_t* status);
 double HAL_GetREVPHSolenoidCurrent(HAL_REVPHHandle handle, int32_t* status);
 double HAL_GetREVPHSolenoidVoltage(HAL_REVPHHandle handle, int32_t* status);
-HAL_REVPHVersion HAL_GetREVPHVersion(HAL_REVPHHandle handle, int32_t* status);
+void HAL_GetREVPHVersion(HAL_REVPHHandle handle, HAL_REVPHVersion* version,
+                         int32_t* status);
 
 int32_t HAL_GetREVPHSolenoids(HAL_REVPHHandle handle, int32_t* status);
 void HAL_SetREVPHSolenoids(HAL_REVPHHandle handle, int32_t mask, int32_t values,
@@ -135,10 +136,12 @@ void HAL_SetREVPHSolenoids(HAL_REVPHHandle handle, int32_t mask, int32_t values,
 void HAL_FireREVPHOneShot(HAL_REVPHHandle handle, int32_t index, int32_t durMs,
                           int32_t* status);
 
-HAL_REVPHFaults HAL_GetREVPHFaults(HAL_REVPHHandle handle, int32_t* status);
+void HAL_GetREVPHFaults(HAL_REVPHHandle handle, HAL_REVPHFaults* faults,
+                        int32_t* status);
 
-HAL_REVPHStickyFaults HAL_GetREVPHStickyFaults(HAL_REVPHHandle handle,
-                                               int32_t* status);
+void HAL_GetREVPHStickyFaults(HAL_REVPHHandle handle,
+                              HAL_REVPHStickyFaults* stickyFaults,
+                              int32_t* status);
 
 void HAL_ClearREVPHStickyFaults(HAL_REVPHHandle handle, int32_t* status);
 

hal/src/main/native/sim/REVPH.cpp

@@ -177,8 +177,8 @@ HAL_Bool HAL_GetREVPHPressureSwitch(HAL_REVPHHandle handle, int32_t* status) {
   return SimREVPHData[pcm->module].pressureSwitch;
 }
 
-double HAL_GetREVPHAnalogPressure(HAL_REVPHHandle handle, int32_t channel,
-                                  int32_t* status) {
+double HAL_GetREVPHAnalogVoltage(HAL_REVPHHandle handle, int32_t channel,
+                                 int32_t* status) {
   return 0;
 }
 
@@ -227,3 +227,31 @@ void HAL_SetREVPHSolenoids(HAL_REVPHHandle handle, int32_t mask, int32_t values,
 
 void HAL_FireREVPHOneShot(HAL_REVPHHandle handle, int32_t index, int32_t durMs,
                           int32_t* status) {}
+
+double HAL_GetREVPHVoltage(HAL_REVPHHandle handle, int32_t* status) {
+  return 0;
+}
+
+double HAL_GetREVPH5VVoltage(HAL_REVPHHandle handle, int32_t* status) {
+  return 0;
+}
+
+double HAL_GetREVPHSolenoidCurrent(HAL_REVPHHandle handle, int32_t* status) {
+  return 0;
+}
+
+double HAL_GetREVPHSolenoidVoltage(HAL_REVPHHandle handle, int32_t* status) {
+  return 0;
+}
+
+void HAL_GetREVPHVersion(HAL_REVPHHandle handle, HAL_REVPHVersion* version,
+                         int32_t* status) {}
+
+void HAL_GetREVPHFaults(HAL_REVPHHandle handle, HAL_REVPHFaults* faults,
+                        int32_t* status) {}
+
+void HAL_GetREVPHStickyFaults(HAL_REVPHHandle handle,
+                              HAL_REVPHStickyFaults* stickyFaults,
+                              int32_t* status) {}
+
+void HAL_ClearREVPHStickyFaults(HAL_REVPHHandle handle, int32_t* status) {}