diff --git a/hal/include/HAL/AnalogAccumulator.h b/hal/include/HAL/AnalogAccumulator.h
index 06de2bdce9..5d6c5a5852 100644
--- 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);
 }
diff --git a/hal/include/HAL/AnalogInput.h b/hal/include/HAL/AnalogInput.h
index 62876fb178..ce436da5fb 100644
--- 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);
 }
diff --git a/hal/include/HAL/AnalogTrigger.h b/hal/include/HAL/AnalogTrigger.h
index 0c09210420..eeb6beefab 100644
--- 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);
 }
diff --git a/hal/include/HAL/Handles.h b/hal/include/HAL/Handles.h
index 18de01185e..fa366260e4 100644
--- 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;
diff --git a/hal/lib/athena/AnalogAccumulator.cpp b/hal/lib/athena/AnalogAccumulator.cpp
index 3181c220c5..1c6ec231bc 100644
--- 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;
diff --git a/hal/lib/athena/AnalogInput.cpp b/hal/lib/athena/AnalogInput.cpp
index 27b7ed2a9e..77caf9c593 100644
--- 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;
diff --git a/hal/lib/athena/AnalogInternal.cpp b/hal/lib/athena/AnalogInternal.cpp
index 88e65677b6..853f3a0523 100644
--- 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;
diff --git a/hal/lib/athena/AnalogInternal.h b/hal/lib/athena/AnalogInternal.h
index 7088625d62..8248bba573 100644
--- 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);
diff --git a/hal/lib/athena/AnalogTrigger.cpp b/hal/lib/athena/AnalogTrigger.cpp
index 0bb9566322..823115298c 100644
--- 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:
diff --git a/hal/lib/athena/handles/HandlesInternal.h b/hal/lib/athena/handles/HandlesInternal.h
index 821d2033e9..71bf3a738b 100644
--- 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) {
diff --git a/wpilibc/athena/include/AnalogInput.h b/wpilibc/athena/include/AnalogInput.h
index 699c4cdf10..e7922da9ad 100644
--- 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;
diff --git a/wpilibc/athena/include/AnalogTrigger.h b/wpilibc/athena/include/AnalogTrigger.h
index 178b77810a..b71e1791fc 100644
--- 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;
 };
diff --git a/wpilibc/athena/src/AnalogInput.cpp b/wpilibc/athena/src/AnalogInput.cpp
index 1734bf37c8..9a243d994e 100644
--- 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;
 }
 
 /**
diff --git a/wpilibc/athena/src/AnalogTrigger.cpp b/wpilibc/athena/src/AnalogTrigger.cpp
index d6b93fa215..88551fb2b3 100644
--- 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;
+  }
 }
 
 /**
diff --git a/wpilibj/src/athena/cpp/lib/AnalogJNI.cpp b/wpilibj/src/athena/cpp/lib/AnalogJNI.cpp
index f441469108..91687a4950 100644
--- 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;
 }
diff --git a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogInput.java b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogInput.java
index a583102699..fcb6b76e32 100644
--- 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;
   }
diff --git a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogTrigger.java b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/AnalogTrigger.java
index a61fb95028..eac3ca79aa 100644
--- 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();
+    }
   }
 
   /**
diff --git a/wpilibj/src/athena/java/edu/wpi/first/wpilibj/hal/AnalogJNI.java b/wpilibj/src/athena/java/edu/wpi/first/wpilibj/hal/AnalogJNI.java
index 45ee90a78b..f7cea993c9 100644
--- 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);
 }