Switches AnalogInputs and AnalogTriggers to Handles (#117)

Results in a breaking change to AnalogTrigger int constructor. If a user wants multiple AnalogTriggers, they must use the AnalogInput constructor.
2026-07-02 02:51:42 +00:00 · 2016-06-27 21:32:30 -07:00
parent 77a1af44c4
commit e8e052712e
18 changed files with 516 additions and 341 deletions
--- a/hal/include/HAL/AnalogAccumulator.h
+++ b/hal/include/HAL/AnalogAccumulator.h
@@ -9,16 +9,21 @@

 #include <stdint.h>

+#include "Handles.h"
+
 extern "C" {
-bool isAccumulatorChannel(void* analog_port_pointer, int32_t* status);
-void initAccumulator(void* analog_port_pointer, int32_t* status);
-void resetAccumulator(void* analog_port_pointer, int32_t* status);
-void setAccumulatorCenter(void* analog_port_pointer, int32_t center,
+bool isAccumulatorChannel(HalAnalogInputHandle analog_port_handle,
                          int32_t* status);
-void setAccumulatorDeadband(void* analog_port_pointer, int32_t deadband,
+void initAccumulator(HalAnalogInputHandle analog_port_handle, int32_t* status);
+void resetAccumulator(HalAnalogInputHandle analog_port_handle, int32_t* status);
+void setAccumulatorCenter(HalAnalogInputHandle analog_port_handle,
+                          int32_t center, int32_t* status);
+void setAccumulatorDeadband(HalAnalogInputHandle analog_port_handle,
+                            int32_t deadband, int32_t* status);
+int64_t getAccumulatorValue(HalAnalogInputHandle analog_port_handle,
                            int32_t* status);
-int64_t getAccumulatorValue(void* analog_port_pointer, int32_t* status);
-uint32_t getAccumulatorCount(void* analog_port_pointer, int32_t* status);
-void getAccumulatorOutput(void* analog_port_pointer, int64_t* value,
-                          uint32_t* count, int32_t* status);
+uint32_t getAccumulatorCount(HalAnalogInputHandle analog_port_handle,
+                             int32_t* status);
+void getAccumulatorOutput(HalAnalogInputHandle analog_port_handle,
+                          int64_t* value, uint32_t* count, int32_t* status);
 }
--- a/hal/include/HAL/AnalogInput.h
+++ b/hal/include/HAL/AnalogInput.h
@@ -13,25 +13,34 @@

 extern "C" {
 // Analog input functions
-void* initializeAnalogInputPort(HalPortHandle port_handle, int32_t* status);
-void freeAnalogInputPort(void* analog_port_pointer);
+HalAnalogInputHandle initializeAnalogInputPort(HalPortHandle port_handle,
+                                               int32_t* status);
+void freeAnalogInputPort(HalAnalogInputHandle analog_port_handle);
 bool checkAnalogModule(uint8_t module);
 bool checkAnalogInputChannel(uint32_t pin);

 void setAnalogSampleRate(double samplesPerSecond, int32_t* status);
 float getAnalogSampleRate(int32_t* status);
-void setAnalogAverageBits(void* analog_port_pointer, uint32_t bits,
-                          int32_t* status);
-uint32_t getAnalogAverageBits(void* analog_port_pointer, int32_t* status);
-void setAnalogOversampleBits(void* analog_port_pointer, uint32_t bits,
-                             int32_t* status);
-uint32_t getAnalogOversampleBits(void* analog_port_pointer, int32_t* status);
-int16_t getAnalogValue(void* analog_port_pointer, int32_t* status);
-int32_t getAnalogAverageValue(void* analog_port_pointer, int32_t* status);
-int32_t getAnalogVoltsToValue(void* analog_port_pointer, double voltage,
+void setAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
+                          uint32_t bits, int32_t* status);
+uint32_t getAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
                              int32_t* status);
-float getAnalogVoltage(void* analog_port_pointer, int32_t* status);
-float getAnalogAverageVoltage(void* analog_port_pointer, int32_t* status);
-uint32_t getAnalogLSBWeight(void* analog_port_pointer, int32_t* status);
-int32_t getAnalogOffset(void* analog_port_pointer, int32_t* status);
+void setAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
+                             uint32_t bits, int32_t* status);
+uint32_t getAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
+                                 int32_t* status);
+int16_t getAnalogValue(HalAnalogInputHandle analog_port_handle,
+                       int32_t* status);
+int32_t getAnalogAverageValue(HalAnalogInputHandle analog_port_handle,
+                              int32_t* status);
+int32_t getAnalogVoltsToValue(HalAnalogInputHandle analog_port_handle,
+                              double voltage, int32_t* status);
+float getAnalogVoltage(HalAnalogInputHandle analog_port_handle,
+                       int32_t* status);
+float getAnalogAverageVoltage(HalAnalogInputHandle analog_port_handle,
+                              int32_t* status);
+uint32_t getAnalogLSBWeight(HalAnalogInputHandle analog_port_handle,
+                            int32_t* status);
+int32_t getAnalogOffset(HalAnalogInputHandle analog_port_handle,
+                        int32_t* status);
 }
--- a/hal/include/HAL/AnalogTrigger.h
+++ b/hal/include/HAL/AnalogTrigger.h
@@ -19,20 +19,23 @@ enum AnalogTriggerType {
 };

 extern "C" {
-void* initializeAnalogTrigger(HalPortHandle port_handle, uint32_t* index,
-                              int32_t* status);
-void cleanAnalogTrigger(void* analog_trigger_pointer, int32_t* status);
-void setAnalogTriggerLimitsRaw(void* analog_trigger_pointer, int32_t lower,
-                               int32_t upper, int32_t* status);
-void setAnalogTriggerLimitsVoltage(void* analog_trigger_pointer, double lower,
-                                   double upper, int32_t* status);
-void setAnalogTriggerAveraged(void* analog_trigger_pointer,
+HalAnalogTriggerHandle initializeAnalogTrigger(HalAnalogInputHandle port_handle,
+                                               uint32_t* index,
+                                               int32_t* status);
+void cleanAnalogTrigger(HalAnalogTriggerHandle analog_trigger_handle,
+                        int32_t* status);
+void setAnalogTriggerLimitsRaw(HalAnalogTriggerHandle analog_trigger_handle,
+                               int32_t lower, int32_t upper, int32_t* status);
+void setAnalogTriggerLimitsVoltage(HalAnalogTriggerHandle analog_trigger_handle,
+                                   double lower, double upper, int32_t* status);
+void setAnalogTriggerAveraged(HalAnalogTriggerHandle analog_trigger_handle,
                              bool useAveragedValue, int32_t* status);
-void setAnalogTriggerFiltered(void* analog_trigger_pointer,
+void setAnalogTriggerFiltered(HalAnalogTriggerHandle analog_trigger_handle,
                              bool useFilteredValue, int32_t* status);
-bool getAnalogTriggerInWindow(void* analog_trigger_pointer, int32_t* status);
-bool getAnalogTriggerTriggerState(void* analog_trigger_pointer,
+bool getAnalogTriggerInWindow(HalAnalogTriggerHandle analog_trigger_handle,
+                              int32_t* status);
+bool getAnalogTriggerTriggerState(HalAnalogTriggerHandle analog_trigger_handle,
                                  int32_t* status);
-bool getAnalogTriggerOutput(void* analog_trigger_pointer,
+bool getAnalogTriggerOutput(HalAnalogTriggerHandle analog_trigger_handle,
                            AnalogTriggerType type, int32_t* status);
 }
--- a/hal/include/HAL/Handles.h
+++ b/hal/include/HAL/Handles.h
@@ -20,3 +20,7 @@ typedef HalHandle HalInterruptHandle;
 typedef HalHandle HalNotifierHandle;

 typedef HalHandle HalAnalogOutputHandle;
+
+typedef HalHandle HalAnalogInputHandle;
+
+typedef HalHandle HalAnalogTriggerHandle;
--- a/hal/lib/athena/AnalogAccumulator.cpp
+++ b/hal/lib/athena/AnalogAccumulator.cpp
@@ -18,8 +18,13 @@ extern "C" {
 *
 *@return The analog channel is attached to an accumulator.
 */
-bool isAccumulatorChannel(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+bool isAccumulatorChannel(HalAnalogInputHandle analog_port_handle,
+                          int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return false;
+  }
  for (uint32_t i = 0; i < kAccumulatorNumChannels; i++) {
    if (port->pin == kAccumulatorChannels[i]) return true;
  }
@@ -29,16 +34,21 @@ bool isAccumulatorChannel(void* analog_port_pointer, int32_t* status) {
 /**
 * Initialize the accumulator.
 */
-void initAccumulator(void* analog_port_pointer, int32_t* status) {
-  setAccumulatorCenter(analog_port_pointer, 0, status);
-  resetAccumulator(analog_port_pointer, status);
+void initAccumulator(HalAnalogInputHandle analog_port_handle, int32_t* status) {
+  setAccumulatorCenter(analog_port_handle, 0, status);
+  resetAccumulator(analog_port_handle, status);
 }

 /**
 * Resets the accumulator to the initial value.
 */
-void resetAccumulator(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void resetAccumulator(HalAnalogInputHandle analog_port_handle,
+                      int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return;
@@ -58,9 +68,13 @@ void resetAccumulator(void* analog_port_pointer, int32_t* status) {
 * source from channel 1. Because of this, any non-zero oversample bits will
 * affect the size of the value for this field.
 */
-void setAccumulatorCenter(void* analog_port_pointer, int32_t center,
-                          int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void setAccumulatorCenter(HalAnalogInputHandle analog_port_handle,
+                          int32_t center, int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return;
@@ -71,9 +85,13 @@ void setAccumulatorCenter(void* analog_port_pointer, int32_t center,
 /**
 * Set the accumulator's deadband.
 */
-void setAccumulatorDeadband(void* analog_port_pointer, int32_t deadband,
-                            int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void setAccumulatorDeadband(HalAnalogInputHandle analog_port_handle,
+                            int32_t deadband, int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return;
@@ -89,8 +107,13 @@ void setAccumulatorDeadband(void* analog_port_pointer, int32_t deadband,
 *
 * @return The 64-bit value accumulated since the last Reset().
 */
-int64_t getAccumulatorValue(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+int64_t getAccumulatorValue(HalAnalogInputHandle analog_port_handle,
+                            int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return 0;
@@ -107,8 +130,13 @@ int64_t getAccumulatorValue(void* analog_port_pointer, int32_t* status) {
 *
 * @return The number of times samples from the channel were accumulated.
 */
-uint32_t getAccumulatorCount(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+uint32_t getAccumulatorCount(HalAnalogInputHandle analog_port_handle,
+                             int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return 0;
@@ -125,9 +153,13 @@ uint32_t getAccumulatorCount(void* analog_port_pointer, int32_t* status) {
 * @param value Pointer to the 64-bit accumulated output.
 * @param count Pointer to the number of accumulation cycles.
 */
-void getAccumulatorOutput(void* analog_port_pointer, int64_t* value,
-                          uint32_t* count, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void getAccumulatorOutput(HalAnalogInputHandle analog_port_handle,
+                          int64_t* value, uint32_t* count, int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (port->accumulator == nullptr) {
    *status = NULL_PARAMETER;
    return;
--- a/hal/lib/athena/AnalogInput.cpp
+++ b/hal/lib/athena/AnalogInput.cpp
@@ -24,37 +24,48 @@ extern "C" {
 /**
 * Initialize the analog input port using the given port object.
 */
-void* initializeAnalogInputPort(HalPortHandle port_handle, int32_t* status) {
+HalAnalogInputHandle initializeAnalogInputPort(HalPortHandle port_handle,
+                                               int32_t* status) {
  initializeAnalog(status);

-  if (*status != 0) return nullptr;
+  if (*status != 0) return HAL_INVALID_HANDLE;

  int16_t pin = getPortHandlePin(port_handle);
  if (pin == InvalidHandleIndex) {
    *status = PARAMETER_OUT_OF_RANGE;
-    return nullptr;
+    return HAL_INVALID_HANDLE;
  }

+  HalAnalogInputHandle handle = analogInputHandles.Allocate(pin, status);
+
+  if (*status != 0)
+    return HAL_INVALID_HANDLE;  // failed to allocate. Pass error back.
+
  // Initialize port structure
-  AnalogPort* analog_port = new AnalogPort();
-  analog_port->pin = (uint8_t)pin;
-  if (isAccumulatorChannel(analog_port, status)) {
+  auto analog_port = analogInputHandles.Get(handle);
+  if (analog_port == nullptr) {  // would only error on thread issue
+    *status = PARAMETER_OUT_OF_RANGE;
+    return HAL_INVALID_HANDLE;
+  }
+  analog_port->pin = static_cast<uint8_t>(pin);
+  if (isAccumulatorChannel(handle, status)) {
    analog_port->accumulator = tAccumulator::create(pin, status);
  } else
    analog_port->accumulator = nullptr;

  // Set default configuration
  analogInputSystem->writeScanList(pin, pin, status);
-  setAnalogAverageBits(analog_port, kDefaultAverageBits, status);
-  setAnalogOversampleBits(analog_port, kDefaultOversampleBits, status);
-  return analog_port;
+  setAnalogAverageBits(handle, kDefaultAverageBits, status);
+  setAnalogOversampleBits(handle, kDefaultOversampleBits, status);
+  return handle;
 }

-void freeAnalogInputPort(void* analog_port_pointer) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void freeAnalogInputPort(HalAnalogInputHandle analog_port_handle) {
+  auto port = analogInputHandles.Get(analog_port_handle);
  if (!port) return;
+  // no status, so no need to check for a proper free.
+  analogInputHandles.Free(analog_port_handle);
  delete port->accumulator;
-  delete port;
 }

 /**
@@ -135,9 +146,13 @@ float getAnalogSampleRate(int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to configure.
 * @param bits Number of bits to average.
 */
-void setAnalogAverageBits(void* analog_port_pointer, uint32_t bits,
-                          int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void setAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
+                          uint32_t bits, int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  analogInputSystem->writeAverageBits(port->pin, bits, status);
 }

@@ -150,8 +165,13 @@ void setAnalogAverageBits(void* analog_port_pointer, uint32_t bits,
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return Bits to average.
 */
-uint32_t getAnalogAverageBits(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+uint32_t getAnalogAverageBits(HalAnalogInputHandle analog_port_handle,
+                              int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return kDefaultAverageBits;
+  }
  uint32_t result = analogInputSystem->readAverageBits(port->pin, status);
  return result;
 }
@@ -167,9 +187,13 @@ uint32_t getAnalogAverageBits(void* analog_port_pointer, int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to use.
 * @param bits Number of bits to oversample.
 */
-void setAnalogOversampleBits(void* analog_port_pointer, uint32_t bits,
-                             int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+void setAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
+                             uint32_t bits, int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  analogInputSystem->writeOversampleBits(port->pin, bits, status);
 }

@@ -183,8 +207,13 @@ void setAnalogOversampleBits(void* analog_port_pointer, uint32_t bits,
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return Bits to oversample.
 */
-uint32_t getAnalogOversampleBits(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+uint32_t getAnalogOversampleBits(HalAnalogInputHandle analog_port_handle,
+                                 int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return kDefaultOversampleBits;
+  }
  uint32_t result = analogInputSystem->readOversampleBits(port->pin, status);
  return result;
 }
@@ -199,8 +228,13 @@ uint32_t getAnalogOversampleBits(void* analog_port_pointer, int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return A sample straight from the channel on this module.
 */
-int16_t getAnalogValue(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+int16_t getAnalogValue(HalAnalogInputHandle analog_port_handle,
+                       int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  int16_t value;
  if (!checkAnalogInputChannel(port->pin)) {
    return 0;
@@ -234,8 +268,13 @@ int16_t getAnalogValue(void* analog_port_pointer, int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return A sample from the oversample and average engine for the channel.
 */
-int32_t getAnalogAverageValue(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+int32_t getAnalogAverageValue(HalAnalogInputHandle analog_port_handle,
+                              int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  int32_t value;
  if (!checkAnalogInputChannel(port->pin)) {
    return 0;
@@ -264,10 +303,11 @@ int32_t getAnalogAverageValue(void* analog_port_pointer, int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return A scaled sample straight from the channel on this module.
 */
-float getAnalogVoltage(void* analog_port_pointer, int32_t* status) {
-  int16_t value = getAnalogValue(analog_port_pointer, status);
-  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_pointer, status);
-  int32_t offset = getAnalogOffset(analog_port_pointer, status);
+float getAnalogVoltage(HalAnalogInputHandle analog_port_handle,
+                       int32_t* status) {
+  int16_t value = getAnalogValue(analog_port_handle, status);
+  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_handle, status);
+  int32_t offset = getAnalogOffset(analog_port_handle, status);
  float voltage = LSBWeight * 1.0e-9 * value - offset * 1.0e-9;
  return voltage;
 }
@@ -285,12 +325,12 @@ float getAnalogVoltage(void* analog_port_pointer, int32_t* status) {
 * @return A scaled sample from the output of the oversample and average engine
 * for the channel.
 */
-float getAnalogAverageVoltage(void* analog_port_pointer, int32_t* status) {
-  int32_t value = getAnalogAverageValue(analog_port_pointer, status);
-  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_pointer, status);
-  int32_t offset = getAnalogOffset(analog_port_pointer, status);
-  uint32_t oversampleBits =
-      getAnalogOversampleBits(analog_port_pointer, status);
+float getAnalogAverageVoltage(HalAnalogInputHandle analog_port_handle,
+                              int32_t* status) {
+  int32_t value = getAnalogAverageValue(analog_port_handle, status);
+  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_handle, status);
+  int32_t offset = getAnalogOffset(analog_port_handle, status);
+  uint32_t oversampleBits = getAnalogOversampleBits(analog_port_handle, status);
  float voltage =
      ((LSBWeight * 1.0e-9 * value) / (float)(1 << oversampleBits)) -
      offset * 1.0e-9;
@@ -309,8 +349,8 @@ float getAnalogAverageVoltage(void* analog_port_pointer, int32_t* status) {
 * @param voltage The voltage to convert.
 * @return The raw value for the channel.
 */
-int32_t getAnalogVoltsToValue(void* analog_port_pointer, double voltage,
-                              int32_t* status) {
+int32_t getAnalogVoltsToValue(HalAnalogInputHandle analog_port_handle,
+                              double voltage, int32_t* status) {
  if (voltage > 5.0) {
    voltage = 5.0;
    *status = VOLTAGE_OUT_OF_RANGE;
@@ -319,8 +359,8 @@ int32_t getAnalogVoltsToValue(void* analog_port_pointer, double voltage,
    voltage = 0.0;
    *status = VOLTAGE_OUT_OF_RANGE;
  }
-  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_pointer, status);
-  int32_t offset = getAnalogOffset(analog_port_pointer, status);
+  uint32_t LSBWeight = getAnalogLSBWeight(analog_port_handle, status);
+  int32_t offset = getAnalogOffset(analog_port_handle, status);
  int32_t value = (int32_t)((voltage + offset * 1.0e-9) / (LSBWeight * 1.0e-9));
  return value;
 }
@@ -335,8 +375,13 @@ int32_t getAnalogVoltsToValue(void* analog_port_pointer, double voltage,
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return Least significant bit weight.
 */
-uint32_t getAnalogLSBWeight(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+uint32_t getAnalogLSBWeight(HalAnalogInputHandle analog_port_handle,
+                            int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  uint32_t lsbWeight = FRC_NetworkCommunication_nAICalibration_getLSBWeight(
      0, port->pin, status);  // XXX: aiSystemIndex == 0?
  return lsbWeight;
@@ -352,8 +397,13 @@ uint32_t getAnalogLSBWeight(void* analog_port_pointer, int32_t* status) {
 * @param analog_port_pointer Pointer to the analog port to use.
 * @return Offset constant.
 */
-int32_t getAnalogOffset(void* analog_port_pointer, int32_t* status) {
-  AnalogPort* port = (AnalogPort*)analog_port_pointer;
+int32_t getAnalogOffset(HalAnalogInputHandle analog_port_handle,
+                        int32_t* status) {
+  auto port = analogInputHandles.Get(analog_port_handle);
+  if (port == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return 0;
+  }
  int32_t offset = FRC_NetworkCommunication_nAICalibration_getOffset(
      0, port->pin, status);  // XXX: aiSystemIndex == 0?
  return offset;
--- a/hal/lib/athena/AnalogInternal.cpp
+++ b/hal/lib/athena/AnalogInternal.cpp
@@ -15,6 +15,11 @@ namespace hal {
 priority_recursive_mutex analogRegisterWindowMutex;
 tAI* analogInputSystem = nullptr;
 tAO* analogOutputSystem = nullptr;
+
+IndexedHandleResource<HalAnalogInputHandle, hal::AnalogPort, kAnalogInputPins,
+                      HalHandleEnum::AnalogInput>
+    analogInputHandles;
+
 static uint32_t analogNumChannelsToActivate = 0;

 bool analogSystemInitialized = false;
--- a/hal/lib/athena/AnalogInternal.h
+++ b/hal/lib/athena/AnalogInternal.h
@@ -11,6 +11,7 @@

 #include "ChipObject.h"
 #include "HAL/cpp/priority_mutex.h"
+#include "handles/IndexedHandleResource.h"

 namespace hal {
 constexpr long kTimebase = 40000000;  ///< 40 MHz clock
@@ -31,6 +32,10 @@ struct AnalogPort {
  tAccumulator* accumulator;
 };

+extern IndexedHandleResource<HalAnalogInputHandle, hal::AnalogPort,
+                             kAnalogInputPins, HalHandleEnum::AnalogInput>
+    analogInputHandles;
+
 uint32_t getAnalogNumActiveChannels(int32_t* status);
 uint32_t getAnalogNumChannelsToActivate(int32_t* status);
 void setAnalogNumChannelsToActivate(uint32_t channels);
--- a/hal/lib/athena/AnalogTrigger.cpp
+++ b/hal/lib/athena/AnalogTrigger.cpp
@@ -12,49 +12,72 @@
 #include "HAL/Errors.h"
 #include "HAL/cpp/Resource.h"
 #include "handles/HandlesInternal.h"
+#include "handles/LimitedHandleResource.h"

 using namespace hal;

-extern "C" {
-struct trigger_t {
+namespace {
+struct AnalogTrigger {
  tAnalogTrigger* trigger;
-  AnalogPort* port;
+  HalAnalogInputHandle analogHandle;
  uint32_t index;
 };
-typedef struct trigger_t AnalogTrigger;
+}

-static hal::Resource* triggers = nullptr;
+static LimitedHandleResource<HalAnalogTriggerHandle, AnalogTrigger,
+                             tAnalogTrigger::kNumSystems,
+                             HalHandleEnum::AnalogTrigger>
+    analogTriggerHandles;

-void* initializeAnalogTrigger(HalPortHandle port_handle, uint32_t* index,
-                              int32_t* status) {
-  hal::Resource::CreateResourceObject(&triggers, tAnalogTrigger::kNumSystems);
+extern "C" {

-  AnalogTrigger* trigger = new AnalogTrigger();
-  trigger->port = (AnalogPort*)initializeAnalogInputPort(port_handle, status);
-  if (*status != 0) {
-    return nullptr;
+HalAnalogTriggerHandle initializeAnalogTrigger(HalAnalogInputHandle port_handle,
+                                               uint32_t* index,
+                                               int32_t* status) {
+  if (port_handle == HAL_INVALID_HANDLE) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return HAL_INVALID_HANDLE;
  }
-  trigger->index = triggers->Allocate("Analog Trigger");
-  *index = trigger->index;
+  HalAnalogInputHandle handle = analogTriggerHandles.Allocate();
+  if (handle == HAL_INVALID_HANDLE) {
+    *status = NO_AVAILABLE_RESOURCES;
+    return HAL_INVALID_HANDLE;
+  }
+  auto trigger = analogTriggerHandles.Get(handle);
+  trigger->analogHandle = port_handle;
+
+  auto analog_port = analogInputHandles.Get(trigger->analogHandle);
+  if (analog_port == nullptr) {  // would only error on thread issue
+    *status = PARAMETER_OUT_OF_RANGE;
+    return HAL_INVALID_HANDLE;
+  }
+  *index = static_cast<uint32_t>(getHandleIndex(handle));
+  trigger->index = *index;
  // TODO: if (index == ~0ul) { CloneError(triggers); return; }

  trigger->trigger = tAnalogTrigger::create(trigger->index, status);
-  trigger->trigger->writeSourceSelect_Channel(trigger->port->pin, status);
-  return trigger;
+  trigger->trigger->writeSourceSelect_Channel(analog_port->pin, status);
+  return handle;
 }

-void cleanAnalogTrigger(void* analog_trigger_pointer, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
-  if (!trigger) return;
-  triggers->Free(trigger->index);
+void cleanAnalogTrigger(HalAnalogTriggerHandle analog_trigger_handle,
+                        int32_t* status) {
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {  // ignore status error
+    return;
+  }
+  analogTriggerHandles.Free(analog_trigger_handle);
+  // caller owns the analog input handle.
  delete trigger->trigger;
-  freeAnalogInputPort(trigger->port);
-  delete trigger;
 }

-void setAnalogTriggerLimitsRaw(void* analog_trigger_pointer, int32_t lower,
-                               int32_t upper, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+void setAnalogTriggerLimitsRaw(HalAnalogTriggerHandle analog_trigger_handle,
+                               int32_t lower, int32_t upper, int32_t* status) {
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (lower > upper) {
    *status = ANALOG_TRIGGER_LIMIT_ORDER_ERROR;
  }
@@ -66,18 +89,24 @@ void setAnalogTriggerLimitsRaw(void* analog_trigger_pointer, int32_t lower,
 * Set the upper and lower limits of the analog trigger.
 * The limits are given as floating point voltage values.
 */
-void setAnalogTriggerLimitsVoltage(void* analog_trigger_pointer, double lower,
-                                   double upper, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+void setAnalogTriggerLimitsVoltage(HalAnalogTriggerHandle analog_trigger_handle,
+                                   double lower, double upper,
+                                   int32_t* status) {
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (lower > upper) {
    *status = ANALOG_TRIGGER_LIMIT_ORDER_ERROR;
  }
+
  // TODO: This depends on the averaged setting.  Only raw values will work as
  // is.
  trigger->trigger->writeLowerLimit(
-      getAnalogVoltsToValue(trigger->port, lower, status), status);
+      getAnalogVoltsToValue(trigger->analogHandle, lower, status), status);
  trigger->trigger->writeUpperLimit(
-      getAnalogVoltsToValue(trigger->port, upper, status), status);
+      getAnalogVoltsToValue(trigger->analogHandle, upper, status), status);
 }

 /**
@@ -85,9 +114,13 @@ void setAnalogTriggerLimitsVoltage(void* analog_trigger_pointer, double lower,
 * If the value is true, then the averaged value is selected for the analog
 * trigger, otherwise the immediate value is used.
 */
-void setAnalogTriggerAveraged(void* analog_trigger_pointer,
+void setAnalogTriggerAveraged(HalAnalogTriggerHandle analog_trigger_handle,
                              bool useAveragedValue, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (trigger->trigger->readSourceSelect_Filter(status) != 0) {
    *status = INCOMPATIBLE_STATE;
    // TODO: wpi_setWPIErrorWithContext(IncompatibleMode, "Hardware does not
@@ -102,9 +135,13 @@ void setAnalogTriggerAveraged(void* analog_trigger_pointer,
 * is designed to help with 360 degree pot applications for the period where the
 * pot crosses through zero.
 */
-void setAnalogTriggerFiltered(void* analog_trigger_pointer,
+void setAnalogTriggerFiltered(HalAnalogTriggerHandle analog_trigger_handle,
                              bool useFilteredValue, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return;
+  }
  if (trigger->trigger->readSourceSelect_Averaged(status) != 0) {
    *status = INCOMPATIBLE_STATE;
    // TODO: wpi_setWPIErrorWithContext(IncompatibleMode, "Hardware does not "
@@ -118,8 +155,13 @@ void setAnalogTriggerFiltered(void* analog_trigger_pointer,
 * True if the analog input is between the upper and lower limits.
 * @return The InWindow output of the analog trigger.
 */
-bool getAnalogTriggerInWindow(void* analog_trigger_pointer, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+bool getAnalogTriggerInWindow(HalAnalogTriggerHandle analog_trigger_handle,
+                              int32_t* status) {
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return false;
+  }
  return trigger->trigger->readOutput_InHysteresis(trigger->index, status) != 0;
 }

@@ -130,9 +172,13 @@ bool getAnalogTriggerInWindow(void* analog_trigger_pointer, int32_t* status) {
 * If in Hysteresis, maintain previous state.
 * @return The TriggerState output of the analog trigger.
 */
-bool getAnalogTriggerTriggerState(void* analog_trigger_pointer,
+bool getAnalogTriggerTriggerState(HalAnalogTriggerHandle analog_trigger_handle,
                                  int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return false;
+  }
  return trigger->trigger->readOutput_OverLimit(trigger->index, status) != 0;
 }

@@ -140,9 +186,13 @@ bool getAnalogTriggerTriggerState(void* analog_trigger_pointer,
 * Get the state of the analog trigger output.
 * @return The state of the analog trigger output.
 */
-bool getAnalogTriggerOutput(void* analog_trigger_pointer,
+bool getAnalogTriggerOutput(HalAnalogTriggerHandle analog_trigger_handle,
                            AnalogTriggerType type, int32_t* status) {
-  AnalogTrigger* trigger = (AnalogTrigger*)analog_trigger_pointer;
+  auto trigger = analogTriggerHandles.Get(analog_trigger_handle);
+  if (trigger == nullptr) {
+    *status = PARAMETER_OUT_OF_RANGE;
+    return false;
+  }
  bool result = false;
  switch (type) {
    case kInWindow:
--- a/hal/lib/athena/handles/HandlesInternal.h
+++ b/hal/lib/athena/handles/HandlesInternal.h
@@ -31,7 +31,9 @@ enum class HalHandleEnum {
  Port = 2,
  Notifier = 3,
  Interrupt = 4,
-  AnalogOutput = 5
+  AnalogOutput = 5,
+  AnalogInput = 6,
+  AnalogTrigger = 7
 };

 static inline int16_t getHandleIndex(HalHandle handle) {
--- a/wpilibc/athena/include/AnalogInput.h
+++ b/wpilibc/athena/include/AnalogInput.h
@@ -9,6 +9,7 @@

 #include <memory>

+#include "HAL/Handles.h"
 #include "LiveWindow/LiveWindowSendable.h"
 #include "PIDSource.h"
 #include "SensorBase.h"
@@ -28,6 +29,8 @@
 class AnalogInput : public SensorBase,
                    public PIDSource,
                    public LiveWindowSendable {
+  friend class AnalogTrigger;
+
 public:
  static const uint8_t kAccumulatorModuleNumber = 1;
  static const uint32_t kAccumulatorNumChannels = 2;
@@ -77,7 +80,7 @@ class AnalogInput : public SensorBase,
 private:
  uint32_t m_channel;
  // TODO: Adjust HAL to avoid use of raw pointers.
-  void* m_port;
+  HalAnalogInputHandle m_port;
  int64_t m_accumulatorOffset;

  std::shared_ptr<ITable> m_table;
--- a/wpilibc/athena/include/AnalogTrigger.h
+++ b/wpilibc/athena/include/AnalogTrigger.h
@@ -8,6 +8,7 @@
 #pragma once

 #include "AnalogTriggerOutput.h"
+#include "HAL/Handles.h"
 #include "SensorBase.h"

 class AnalogInput;
@@ -32,5 +33,7 @@ class AnalogTrigger : public SensorBase {

 private:
  uint8_t m_index;
-  void* m_trigger;
+  HalAnalogTriggerHandle m_trigger;
+  AnalogInput* m_analogInput = nullptr;
+  bool m_ownsAnalog = false;
 };
--- a/wpilibc/athena/src/AnalogInput.cpp
+++ b/wpilibc/athena/src/AnalogInput.cpp
@@ -14,8 +14,6 @@

 #include <sstream>

-static std::unique_ptr<Resource> inputs;
-
 const uint8_t AnalogInput::kAccumulatorModuleNumber;
 const uint32_t AnalogInput::kAccumulatorNumChannels;
 const uint32_t AnalogInput::kAccumulatorChannels[] = {0, 1};
@@ -29,25 +27,23 @@ const uint32_t AnalogInput::kAccumulatorChannels[] = {0, 1};
 AnalogInput::AnalogInput(uint32_t channel) {
  std::stringstream buf;
  buf << "Analog Input " << channel;
-  Resource::CreateResourceObject(inputs, kAnalogInputs);

  if (!checkAnalogInputChannel(channel)) {
    wpi_setWPIErrorWithContext(ChannelIndexOutOfRange, buf.str());
    return;
  }

-  if (inputs->Allocate(channel, buf.str()) ==
-      std::numeric_limits<uint32_t>::max()) {
-    CloneError(*inputs);
-    return;
-  }
-
  m_channel = channel;

  HalPortHandle port = getPort(channel);
  int32_t status = 0;
  m_port = initializeAnalogInputPort(port, &status);
-  wpi_setErrorWithContext(status, getHALErrorMessage(status));
+  if (status != 0) {
+    wpi_setErrorWithContext(status, getHALErrorMessage(status));
+    m_channel = std::numeric_limits<uint32_t>::max();
+    m_port = HAL_INVALID_HANDLE;
+    return;
+  }

  LiveWindow::GetInstance()->AddSensor("AnalogInput", channel, this);
  HALReport(HALUsageReporting::kResourceType_AnalogChannel, channel);
@@ -58,7 +54,7 @@ AnalogInput::AnalogInput(uint32_t channel) {
 */
 AnalogInput::~AnalogInput() {
  freeAnalogInputPort(m_port);
-  inputs->Free(m_channel);
+  m_port = HAL_INVALID_HANDLE;
 }

 /**
--- a/wpilibc/athena/src/AnalogTrigger.cpp
+++ b/wpilibc/athena/src/AnalogTrigger.cpp
@@ -20,15 +20,9 @@
 * @param channel The channel number on the roboRIO to represent. 0-3 are
 *                on-board 4-7 are on the MXP port.
 */
-AnalogTrigger::AnalogTrigger(int32_t channel) {
-  HalPortHandle port = getPort(channel);
-  int32_t status = 0;
-  uint32_t index = 0;
-  m_trigger = initializeAnalogTrigger(port, &index, &status);
-  wpi_setErrorWithContext(status, getHALErrorMessage(status));
-  m_index = index;
-
-  HALReport(HALUsageReporting::kResourceType_AnalogTrigger, channel);
+AnalogTrigger::AnalogTrigger(int32_t channel)
+    : AnalogTrigger(new AnalogInput(channel)) {
+  m_ownsAnalog = true;
 }

 /**
@@ -39,13 +33,29 @@ AnalogTrigger::AnalogTrigger(int32_t channel) {
 *
 * @param channel The pointer to the existing AnalogInput object
 */
-AnalogTrigger::AnalogTrigger(AnalogInput* input)
-    : AnalogTrigger(input->GetChannel()) {}
+AnalogTrigger::AnalogTrigger(AnalogInput* input) {
+  m_analogInput = input;
+  int32_t status = 0;
+  uint32_t index = 0;
+  m_trigger = initializeAnalogTrigger(input->m_port, &index, &status);
+  if (status != 0) {
+    wpi_setErrorWithContext(status, getHALErrorMessage(status));
+    m_index = std::numeric_limits<uint8_t>::max();
+    m_trigger = HAL_INVALID_HANDLE;
+    return;
+  }
+  m_index = index;
+
+  HALReport(HALUsageReporting::kResourceType_AnalogTrigger, input->m_channel);
+}

 AnalogTrigger::~AnalogTrigger() {
  int32_t status = 0;
  cleanAnalogTrigger(m_trigger, &status);
-  wpi_setErrorWithContext(status, getHALErrorMessage(status));
+
+  if (m_ownsAnalog && m_analogInput != nullptr) {
+    delete m_analogInput;
+  }
 }

 /**
--- a/wpilibj/src/athena/cpp/lib/AnalogJNI.cpp
+++ b/wpilibj/src/athena/cpp/lib/AnalogJNI.cpp
@@ -31,30 +31,30 @@ extern "C" {
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    initializeAnalogInputPort
- * Signature: (I)J
+ * Signature: (I)I
 */
-JNIEXPORT jlong JNICALL
+JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initializeAnalogInputPort(
    JNIEnv *env, jclass, jint id) {
  ANALOGJNI_LOG(logDEBUG) << "Port Handle = " << (HalPortHandle)id;
  int32_t status = 0;
-  void *analog = initializeAnalogInputPort((HalPortHandle)id, &status);
+  auto analog = initializeAnalogInputPort((HalPortHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << analog;
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << analog;
  CheckStatus(env, status);
-  return (jlong)analog;
+  return (jint)analog;
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    freeAnalogInputPort
- * Signature: (J)V
+ * Signature: (I)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_freeAnalogInputPort(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Port Ptr = " << (void *)id;
-  freeAnalogInputPort((void *)id);
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Port Handle = " << (HalAnalogInputHandle)id;
+  freeAnalogInputPort((HalAnalogInputHandle)id);
 }

 /*
@@ -194,15 +194,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogSampleRate(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogAverageBits
- * Signature: (JI)V
+ * Signature: (II)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogAverageBits(
-    JNIEnv *env, jclass, jlong id, jint value) {
+    JNIEnv *env, jclass, jint id, jint value) {
  ANALOGJNI_LOG(logDEBUG) << "AverageBits = " << value;
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  setAnalogAverageBits((void *)id, value, &status);
+  setAnalogAverageBits((HalAnalogInputHandle)id, value, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -210,14 +210,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogAverageBits(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogAverageBits
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageBits(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  jint returnValue = getAnalogAverageBits((void *)id, &status);
+  jint returnValue = getAnalogAverageBits((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AverageBits = " << returnValue;
  CheckStatus(env, status);
@@ -227,15 +227,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageBits(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogOversampleBits
- * Signature: (JI)V
+ * Signature: (II)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogOversampleBits(
-    JNIEnv *env, jclass, jlong id, jint value) {
+    JNIEnv *env, jclass, jint id, jint value) {
  ANALOGJNI_LOG(logDEBUG) << "OversampleBits = " << value;
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  setAnalogOversampleBits((void *)id, value, &status);
+  setAnalogOversampleBits((HalAnalogInputHandle)id, value, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -243,14 +243,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogOversampleBits(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogOversampleBits
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOversampleBits(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  jint returnValue = getAnalogOversampleBits((void *)id, &status);
+  jint returnValue = getAnalogOversampleBits((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "OversampleBits = " << returnValue;
  CheckStatus(env, status);
@@ -260,14 +260,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOversampleBits(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogValue
- * Signature: (J)S
+ * Signature: (I)S
 */
 JNIEXPORT jshort JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogValue(
-    JNIEnv *env, jclass, jlong id) {
-  // ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void*)id;
+    JNIEnv *env, jclass, jint id) {
+  // ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (void*)id;
  int32_t status = 0;
-  jshort returnValue = getAnalogValue((void *)id, &status);
+  jshort returnValue = getAnalogValue((HalAnalogInputHandle)id, &status);
  // ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  // ANALOGJNI_LOG(logDEBUG) << "Value = " << returnValue;
  CheckStatus(env, status);
@@ -277,14 +277,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogValue(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogAverageValue
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageValue(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  jint returnValue = getAnalogAverageValue((void *)id, &status);
+  jint returnValue = getAnalogAverageValue((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AverageValue = " << returnValue;
  CheckStatus(env, status);
@@ -294,15 +294,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageValue(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogVoltsToValue
- * Signature: (JD)I
+ * Signature: (ID)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltsToValue(
-    JNIEnv *env, jclass, jlong id, jdouble voltageValue) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id, jdouble voltageValue) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  ANALOGJNI_LOG(logDEBUG) << "VoltageValue = " << voltageValue;
  int32_t status = 0;
-  jint returnValue = getAnalogVoltsToValue((void *)id, voltageValue, &status);
+  jint returnValue = getAnalogVoltsToValue((HalAnalogInputHandle)id, voltageValue, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "Value = " << returnValue;
  CheckStatus(env, status);
@@ -312,14 +312,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltsToValue(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogVoltage
- * Signature: (J)D
+ * Signature: (I)D
 */
 JNIEXPORT jdouble JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltage(
-    JNIEnv *env, jclass, jlong id) {
-  // ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void*)id;
+    JNIEnv *env, jclass, jint id) {
+  // ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (void*)id;
  int32_t status = 0;
-  jdouble returnValue = getAnalogVoltage((void *)id, &status);
+  jdouble returnValue = getAnalogVoltage((HalAnalogInputHandle)id, &status);
  // ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  // ANALOGJNI_LOG(logDEBUG) << "Voltage = " << returnValue;
  CheckStatus(env, status);
@@ -329,14 +329,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogVoltage(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogAverageVoltage
- * Signature: (J)D
+ * Signature: (I)D
 */
 JNIEXPORT jdouble JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageVoltage(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  jdouble returnValue = getAnalogAverageVoltage((void *)id, &status);
+  jdouble returnValue = getAnalogAverageVoltage((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AverageVoltage = " << returnValue;
  CheckStatus(env, status);
@@ -346,15 +346,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogAverageVoltage(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogLSBWeight
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogLSBWeight(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  jint returnValue = getAnalogLSBWeight((void *)id, &status);
+  jint returnValue = getAnalogLSBWeight((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AnalogLSBWeight = " << returnValue;
  CheckStatus(env, status);
@@ -364,14 +364,14 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogLSBWeight(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogOffset
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOffset(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  jint returnValue = getAnalogOffset((void *)id, &status);
+  jint returnValue = getAnalogOffset((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AnalogOffset = " << returnValue;
  CheckStatus(env, status);
@@ -381,16 +381,16 @@ JNIEXPORT jint JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogOffset(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    isAccumulatorChannel
- * Signature: (J)Z
+ * Signature: (I)Z
 */
 JNIEXPORT jboolean JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_isAccumulatorChannel(
-    JNIEnv *env, jclass, jlong id) {
+    JNIEnv *env, jclass, jint id) {
  ANALOGJNI_LOG(logDEBUG) << "isAccumulatorChannel";
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  jboolean returnValue = isAccumulatorChannel((void *)id, &status);
+  jboolean returnValue = isAccumulatorChannel((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AnalogOffset = " << returnValue;
  CheckStatus(env, status);
@@ -400,13 +400,13 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_isAccumulatorChannel(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    initAccumulator
- * Signature: (J)V
+ * Signature: (I)V
 */
 JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initAccumulator(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;
-  initAccumulator((void *)id, &status);
+  initAccumulator((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -414,15 +414,15 @@ JNIEXPORT void JNICALL Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initAccumulator(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    resetAccumulator
- * Signature: (J)V
+ * Signature: (I)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_resetAccumulator(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  resetAccumulator((void *)id, &status);
+  resetAccumulator((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -430,15 +430,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_resetAccumulator(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAccumulatorCenter
- * Signature: (JI)V
+ * Signature: (II)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorCenter(
-    JNIEnv *env, jclass, jlong id, jint center) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id, jint center) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  setAccumulatorCenter((void *)id, center, &status);
+  setAccumulatorCenter((HalAnalogInputHandle)id, center, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -446,15 +446,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorCenter(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAccumulatorDeadband
- * Signature: (JI)V
+ * Signature: (II)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorDeadband(
-    JNIEnv *env, jclass, jlong id, jint deadband) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id, jint deadband) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  setAccumulatorDeadband((void *)id, deadband, &status);
+  setAccumulatorDeadband((HalAnalogInputHandle)id, deadband, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  CheckStatus(env, status);
 }
@@ -462,15 +462,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAccumulatorDeadband(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAccumulatorValue
- * Signature: (J)J
+ * Signature: (I)J
 */
 JNIEXPORT jlong JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorValue(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  jlong returnValue = getAccumulatorValue((void *)id, &status);
+  jlong returnValue = getAccumulatorValue((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AccumulatorValue = " << returnValue;
  CheckStatus(env, status);
@@ -481,15 +481,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorValue(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAccumulatorCount
- * Signature: (J)I
+ * Signature: (I)I
 */
 JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorCount(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

-  jint returnValue = getAccumulatorCount((void *)id, &status);
+  jint returnValue = getAccumulatorCount((HalAnalogInputHandle)id, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
  ANALOGJNI_LOG(logDEBUG) << "AccumulatorCount = " << returnValue;
  CheckStatus(env, status);
@@ -499,18 +499,18 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorCount(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAccumulatorOutput
- * Signature: (JLjava/nio/LongBuffer;Ljava/nio/IntBuffer;)V
+ * Signature: (ILjava/nio/LongBuffer;Ljava/nio/IntBuffer;)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorOutput(
-    JNIEnv *env, jclass, jlong id, jobject value, jobject count) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Ptr = " << (void *)id;
+    JNIEnv *env, jclass, jint id, jobject value, jobject count) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Handle = " << (HalAnalogInputHandle)id;
  int32_t status = 0;

  jlong *valuePtr = (jlong *)env->GetDirectBufferAddress(value);
  uint32_t *countPtr = (uint32_t *)env->GetDirectBufferAddress(count);

-  getAccumulatorOutput((void *)id, valuePtr, countPtr, &status);
+  getAccumulatorOutput((HalAnalogInputHandle)id, valuePtr, countPtr, &status);

  ANALOGJNI_LOG(logDEBUG) << "Value = " << *valuePtr;
  ANALOGJNI_LOG(logDEBUG) << "Count = " << *countPtr;
@@ -523,110 +523,110 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAccumulatorOutput(
 * Method:    initializeAnalogTrigger
 * Signature: (ILjava/nio/IntBuffer;)J
 */
-JNIEXPORT jlong JNICALL
+JNIEXPORT jint JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_initializeAnalogTrigger(
    JNIEnv *env, jclass, jint id, jobject index) {
-  ANALOGJNI_LOG(logDEBUG) << "Port Ptr = " << (HalPortHandle)id;
+  ANALOGJNI_LOG(logDEBUG) << "Port Handle = " << (HalAnalogInputHandle)id;

-  jint *indexPtr = (jint *)env->GetDirectBufferAddress(index);
-  ANALOGJNI_LOG(logDEBUG) << "Index Ptr = " << indexPtr;
+  jint *indexHandle = (jint *)env->GetDirectBufferAddress(index);
+  ANALOGJNI_LOG(logDEBUG) << "Index Ptr = " << indexHandle;

  int32_t status = 0;
-  void *analogTrigger =
-      initializeAnalogTrigger((HalPortHandle)id, (uint32_t *)indexPtr, &status);
+  HalAnalogTriggerHandle analogTrigger =
+      initializeAnalogTrigger((HalAnalogInputHandle)id, (uint32_t *)indexHandle, &status);
  ANALOGJNI_LOG(logDEBUG) << "Status = " << status;
-  ANALOGJNI_LOG(logDEBUG) << "AnalogTrigger Ptr = " << analogTrigger;
+  ANALOGJNI_LOG(logDEBUG) << "AnalogTrigger Handle = " << analogTrigger;
  CheckStatus(env, status);
-  return (jlong)analogTrigger;
+  return (jint)analogTrigger;
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    cleanAnalogTrigger
- * Signature: (J)V
+ * Signature: (I)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_cleanAnalogTrigger(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  cleanAnalogTrigger((void *)id, &status);
+  cleanAnalogTrigger((HalAnalogTriggerHandle)id, &status);
  CheckStatus(env, status);
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogTriggerLimitsRaw
- * Signature: (JII)V
+ * Signature: (III)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerLimitsRaw(
-    JNIEnv *env, jclass, jlong id, jint lower, jint upper) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id, jint lower, jint upper) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  setAnalogTriggerLimitsRaw((void *)id, lower, upper, &status);
+  setAnalogTriggerLimitsRaw((HalAnalogTriggerHandle)id, lower, upper, &status);
  CheckStatus(env, status);
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogTriggerLimitsVoltage
- * Signature: (JDD)V
+ * Signature: (IDD)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerLimitsVoltage(
-    JNIEnv *env, jclass, jlong id, jdouble lower, jdouble upper) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id, jdouble lower, jdouble upper) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  setAnalogTriggerLimitsVoltage((void *)id, lower, upper, &status);
+  setAnalogTriggerLimitsVoltage((HalAnalogTriggerHandle)id, lower, upper, &status);
  CheckStatus(env, status);
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogTriggerAveraged
- * Signature: (JZ)V
+ * Signature: (IZ)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerAveraged(
-    JNIEnv *env, jclass, jlong id, jboolean averaged) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id, jboolean averaged) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  setAnalogTriggerAveraged((void *)id, averaged, &status);
+  setAnalogTriggerAveraged((HalAnalogTriggerHandle)id, averaged, &status);
  CheckStatus(env, status);
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    setAnalogTriggerFiltered
- * Signature: (JZ)V
+ * Signature: (IZ)V
 */
 JNIEXPORT void JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_setAnalogTriggerFiltered(
-    JNIEnv *env, jclass, jlong id, jboolean filtered) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id, jboolean filtered) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  setAnalogTriggerFiltered((void *)id, filtered, &status);
+  setAnalogTriggerFiltered((HalAnalogTriggerHandle)id, filtered, &status);
  CheckStatus(env, status);
 }

 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogTriggerInWindow
- * Signature: (J)Z
+ * Signature: (I)Z
 */
 JNIEXPORT jboolean JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerInWindow(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  jboolean val = getAnalogTriggerInWindow((void *)id, &status);
+  jboolean val = getAnalogTriggerInWindow((HalAnalogTriggerHandle)id, &status);
  CheckStatus(env, status);
  return val;
 }
@@ -634,15 +634,15 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerInWindow(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogTriggerTriggerState
- * Signature: (J)Z
+ * Signature: (I)Z
 */
 JNIEXPORT jboolean JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerTriggerState(
-    JNIEnv *env, jclass, jlong id) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
-  jboolean val = getAnalogTriggerTriggerState((void *)id, &status);
+  jboolean val = getAnalogTriggerTriggerState((HalAnalogTriggerHandle)id, &status);
  CheckStatus(env, status);
  return val;
 }
@@ -650,16 +650,16 @@ Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerTriggerState(
 /*
 * Class:     edu_wpi_first_wpilibj_hal_AnalogJNI
 * Method:    getAnalogTriggerOutput
- * Signature: (JI)Z
+ * Signature: (II)Z
 */
 JNIEXPORT jboolean JNICALL
 Java_edu_wpi_first_wpilibj_hal_AnalogJNI_getAnalogTriggerOutput(
-    JNIEnv *env, jclass, jlong id, jint type) {
-  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Ptr = " << (void *)id;
+    JNIEnv *env, jclass,jint id, jint type) {
+  ANALOGJNI_LOG(logDEBUG) << "Analog Trigger Handle = " << (HalAnalogTriggerHandle)id;

  int32_t status = 0;
  jboolean val =
-      getAnalogTriggerOutput((void *)id, (AnalogTriggerType)type, &status);
+      getAnalogTriggerOutput((HalAnalogTriggerHandle)id, (AnalogTriggerType)type, &status);
  CheckStatus(env, status);
  return val;
 }
--- a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogInput.java
+++ b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogInput.java
@@ -17,7 +17,6 @@ import edu.wpi.first.wpilibj.livewindow.LiveWindow;
 import edu.wpi.first.wpilibj.livewindow.LiveWindowSendable;
 import edu.wpi.first.wpilibj.tables.ITable;
 import edu.wpi.first.wpilibj.util.AllocationException;
-import edu.wpi.first.wpilibj.util.CheckedAllocationException;

 /**
 * Analog channel class.
@@ -34,8 +33,7 @@ import edu.wpi.first.wpilibj.util.CheckedAllocationException;
 public class AnalogInput extends SensorBase implements PIDSource, LiveWindowSendable {

  private static final int kAccumulatorSlot = 1;
-  private static Resource channels = new Resource(kAnalogInputChannels);
-  private long m_port;
+  int m_port; // explicit no modifier, private and package accessable.
  private int m_channel;
  private static final int[] kAccumulatorChannels = {0, 1};
  private long m_accumulatorOffset;
@@ -53,11 +51,6 @@ public class AnalogInput extends SensorBase implements PIDSource, LiveWindowSend
      throw new AllocationException("Analog input channel " + m_channel
          + " cannot be allocated. Channel is not present.");
    }
-    try {
-      channels.allocate(channel);
-    } catch (CheckedAllocationException ex) {
-      throw new AllocationException("Analog input channel " + m_channel + " is already allocated");
-    }

    final int portHandle = AnalogJNI.getPort((byte) channel);
    m_port = AnalogJNI.initializeAnalogInputPort(portHandle);
@@ -72,7 +65,6 @@ public class AnalogInput extends SensorBase implements PIDSource, LiveWindowSend
  public void free() {
    AnalogJNI.freeAnalogInputPort(m_port);
    m_port = 0;
-    channels.free(m_channel);
    m_channel = 0;
    m_accumulatorOffset = 0;
  }
--- a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogTrigger.java
+++ b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogTrigger.java
@@ -42,8 +42,10 @@ public class AnalogTrigger {
  /**
   * Where the analog trigger is attached.
   */
-  protected long m_port;
+  protected int m_port;
  protected int m_index;
+  protected AnalogInput m_analogInput = null;
+  protected boolean m_ownsAnalog = false;

  /**
   * Constructor for an analog trigger given a channel number.
@@ -51,15 +53,8 @@ public class AnalogTrigger {
   * @param channel the port to use for the analog trigger
   */
  public AnalogTrigger(final int channel) {
-    final int portHandle = AnalogJNI.getPort((byte) channel);
-    ByteBuffer index = ByteBuffer.allocateDirect(4);
-    index.order(ByteOrder.LITTLE_ENDIAN);
-
-    m_port =
-        AnalogJNI.initializeAnalogTrigger(portHandle, index.asIntBuffer());
-    m_index = index.asIntBuffer().get(0);
-
-    UsageReporting.report(tResourceType.kResourceType_AnalogTrigger, channel);
+    this(new AnalogInput(channel));
+    m_ownsAnalog = true;
  }

  /**
@@ -69,7 +64,15 @@ public class AnalogTrigger {
   * @param channel the AnalogInput to use for the analog trigger
   */
  public AnalogTrigger(AnalogInput channel) {
-    this(requireNonNull(channel, "The Analog Input given was null").getChannel());
+    m_analogInput = channel;
+    ByteBuffer index = ByteBuffer.allocateDirect(4);
+    index.order(ByteOrder.LITTLE_ENDIAN);
+
+    m_port =
+        AnalogJNI.initializeAnalogTrigger(channel.m_port, index.asIntBuffer());
+    m_index = index.asIntBuffer().get(0);
+
+    UsageReporting.report(tResourceType.kResourceType_AnalogTrigger, channel.getChannel());  
  }

  /**
@@ -78,6 +81,9 @@ public class AnalogTrigger {
  public void free() {
    AnalogJNI.cleanAnalogTrigger(m_port);
    m_port = 0;
+    if (m_ownsAnalog && m_analogInput != null) {
+      m_analogInput.free();
+    }
  }

  /**
--- a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/hal/AnalogJNI.java
+++ b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/hal/AnalogJNI.java
@@ -33,9 +33,9 @@ public class AnalogJNI extends JNIWrapper {
    int kFallingPulse = 3;
  }

-  public static native long initializeAnalogInputPort(int halPortHandle);
+  public static native int initializeAnalogInputPort(int halPortHandle);

-  public static native void freeAnalogInputPort(long portPointer);
+  public static native void freeAnalogInputPort(int portHandle);

  public static native int initializeAnalogOutputPort(int halPortHandle);

@@ -55,64 +55,64 @@ public class AnalogJNI extends JNIWrapper {

  public static native double getAnalogSampleRate();

-  public static native void setAnalogAverageBits(long analogPortPointer, int bits);
+  public static native void setAnalogAverageBits(int analogPortHandle, int bits);

-  public static native int getAnalogAverageBits(long analogPortPointer);
+  public static native int getAnalogAverageBits(int analogPortHandle);

-  public static native void setAnalogOversampleBits(long analogPortPointer, int bits);
+  public static native void setAnalogOversampleBits(int analogPortHandle, int bits);

-  public static native int getAnalogOversampleBits(long analogPortPointer);
+  public static native int getAnalogOversampleBits(int analogPortHandle);

-  public static native short getAnalogValue(long analogPortPointer);
+  public static native short getAnalogValue(int analogPortHandle);

-  public static native int getAnalogAverageValue(long analogPortPointer);
+  public static native int getAnalogAverageValue(int analogPortHandle);

-  public static native int getAnalogVoltsToValue(long analogPortPointer, double voltage);
+  public static native int getAnalogVoltsToValue(int analogPortHandle, double voltage);

-  public static native double getAnalogVoltage(long analogPortPointer);
+  public static native double getAnalogVoltage(int analogPortHandle);

-  public static native double getAnalogAverageVoltage(long analogPortPointer);
+  public static native double getAnalogAverageVoltage(int analogPortHandle);

-  public static native int getAnalogLSBWeight(long analogPortPointer);
+  public static native int getAnalogLSBWeight(int analogPortHandle);

-  public static native int getAnalogOffset(long analogPortPointer);
+  public static native int getAnalogOffset(int analogPortHandle);

-  public static native boolean isAccumulatorChannel(long analogPortPointer);
+  public static native boolean isAccumulatorChannel(int analogPortHandle);

-  public static native void initAccumulator(long analogPortPointer);
+  public static native void initAccumulator(int analogPortHandle);

-  public static native void resetAccumulator(long analogPortPointer);
+  public static native void resetAccumulator(int analogPortHandle);

-  public static native void setAccumulatorCenter(long analogPortPointer, int center);
+  public static native void setAccumulatorCenter(int analogPortHandle, int center);

-  public static native void setAccumulatorDeadband(long analogPortPointer, int deadband);
+  public static native void setAccumulatorDeadband(int analogPortHandle, int deadband);

-  public static native long getAccumulatorValue(long analogPortPointer);
+  public static native long getAccumulatorValue(int analogPortHandle);

-  public static native int getAccumulatorCount(long analogPortPointer);
+  public static native int getAccumulatorCount(int analogPortHandle);

-  public static native void getAccumulatorOutput(long analogPortPointer, LongBuffer value,
+  public static native void getAccumulatorOutput(int analogPortHandle, LongBuffer value,
                                                 IntBuffer count);

-  public static native long initializeAnalogTrigger(int halPortHandle, IntBuffer index);
+  public static native int initializeAnalogTrigger(int analogInputHandle, IntBuffer index);

-  public static native void cleanAnalogTrigger(long analogTriggerPointer);
+  public static native void cleanAnalogTrigger(int analogTriggerHandle);

-  public static native void setAnalogTriggerLimitsRaw(long analogTriggerPointer, int lower,
+  public static native void setAnalogTriggerLimitsRaw(int analogTriggerHandle, int lower,
                                                      int upper);

-  public static native void setAnalogTriggerLimitsVoltage(long analogTriggerPointer,
+  public static native void setAnalogTriggerLimitsVoltage(int analogTriggerHandle,
                                                          double lower, double upper);

-  public static native void setAnalogTriggerAveraged(long analogTriggerPointer,
+  public static native void setAnalogTriggerAveraged(int analogTriggerHandle,
                                                     boolean useAveragedValue);

-  public static native void setAnalogTriggerFiltered(long analogTriggerPointer,
+  public static native void setAnalogTriggerFiltered(int analogTriggerHandle,
                                                     boolean useFilteredValue);

-  public static native boolean getAnalogTriggerInWindow(long analogTriggerPointer);
+  public static native boolean getAnalogTriggerInWindow(int analogTriggerHandle);

-  public static native boolean getAnalogTriggerTriggerState(long analogTriggerPointer);
+  public static native boolean getAnalogTriggerTriggerState(int analogTriggerHandle);

-  public static native boolean getAnalogTriggerOutput(long analogTriggerPointer, int type);
+  public static native boolean getAnalogTriggerOutput(int analogTriggerHandle, int type);
 }