Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-20 00:51:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

[hal, wpilib] Remove analog accumulator and analog gyro (#7697)

Browse Source 
The 2 high level classes were temporarily kept to keep the examples compiling. We will remove those when we have the interface into the built in IMU.
This commit is contained in:
Thad House
2025-01-17 12:58:31 -08:00
committed by GitHub
parent 92f0a3c961
commit f80874dd4b
76 changed files with 33 additions and 3886 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
hal/src/main/native/cpp/jni/AnalogGyroJNI.cpp
View File

@@ -1,196 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <jni.h>
#include <cassert>
#include <wpi/jni_util.h>
#include "HALUtil.h"
#include "edu_wpi_first_hal_AnalogGyroJNI.h"
#include "hal/AnalogGyro.h"
#include "hal/handles/HandlesInternal.h"
using namespace hal;
extern "C" {
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: initializeAnalogGyro
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_initializeAnalogGyro
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
auto stack = wpi::java::GetJavaStackTrace(env, "edu.wpi.first");
HAL_GyroHandle handle = HAL_InitializeAnalogGyro((HAL_AnalogInputHandle)id,
stack.c_str(), &status);
// Analog input does range checking, so we don't need to do so.
CheckStatusForceThrow(env, status);
return (jint)handle;
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: setupAnalogGyro
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_setupAnalogGyro
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
HAL_SetupAnalogGyro((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: freeAnalogGyro
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_freeAnalogGyro
(JNIEnv* env, jclass, jint id)
{
if (id != HAL_kInvalidHandle) {
HAL_FreeAnalogGyro((HAL_GyroHandle)id);
}
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: setAnalogGyroParameters
* Signature: (IDDI)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_setAnalogGyroParameters
(JNIEnv* env, jclass, jint id, jdouble vPDPS, jdouble offset, jint center)
{
int32_t status = 0;
HAL_SetAnalogGyroParameters((HAL_GyroHandle)id, vPDPS, offset, center,
&status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: setAnalogGyroVoltsPerDegreePerSecond
* Signature: (ID)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_setAnalogGyroVoltsPerDegreePerSecond
(JNIEnv* env, jclass, jint id, jdouble vPDPS)
{
int32_t status = 0;
HAL_SetAnalogGyroVoltsPerDegreePerSecond((HAL_GyroHandle)id, vPDPS, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: resetAnalogGyro
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_resetAnalogGyro
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
HAL_ResetAnalogGyro((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: calibrateAnalogGyro
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_calibrateAnalogGyro
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
HAL_CalibrateAnalogGyro((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: setAnalogGyroDeadband
* Signature: (ID)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_setAnalogGyroDeadband
(JNIEnv* env, jclass, jint id, jdouble deadband)
{
int32_t status = 0;
HAL_SetAnalogGyroDeadband((HAL_GyroHandle)id, deadband, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: getAnalogGyroAngle
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_getAnalogGyroAngle
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jdouble value = HAL_GetAnalogGyroAngle((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
return value;
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: getAnalogGyroRate
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_getAnalogGyroRate
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jdouble value = HAL_GetAnalogGyroRate((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
return value;
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: getAnalogGyroOffset
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_getAnalogGyroOffset
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jdouble value = HAL_GetAnalogGyroOffset((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
return value;
}
/*
* Class: edu_wpi_first_hal_AnalogGyroJNI
* Method: getAnalogGyroCenter
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_AnalogGyroJNI_getAnalogGyroCenter
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jint value = HAL_GetAnalogGyroCenter((HAL_GyroHandle)id, &status);
CheckStatus(env, status);
return value;
}
} // extern "C"

124
hal/src/main/native/cpp/jni/AnalogJNI.cpp
View File

@@ -10,7 +10,6 @@
#include "HALUtil.h"
#include "edu_wpi_first_hal_AnalogJNI.h"
#include "hal/AnalogAccumulator.h"
#include "hal/AnalogInput.h"
#include "hal/AnalogTrigger.h"
#include "hal/Ports.h"
@@ -306,129 +305,6 @@ Java_edu_wpi_first_hal_AnalogJNI_getAnalogOffset
return returnValue;
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: isAccumulatorChannel
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_hal_AnalogJNI_isAccumulatorChannel
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jboolean returnValue =
HAL_IsAccumulatorChannel((HAL_AnalogInputHandle)id, &status);
CheckStatus(env, status);
return returnValue;
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: initAccumulator
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogJNI_initAccumulator
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
HAL_InitAccumulator((HAL_AnalogInputHandle)id, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: resetAccumulator
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogJNI_resetAccumulator
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
HAL_ResetAccumulator((HAL_AnalogInputHandle)id, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: setAccumulatorCenter
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogJNI_setAccumulatorCenter
(JNIEnv* env, jclass, jint id, jint center)
{
int32_t status = 0;
HAL_SetAccumulatorCenter((HAL_AnalogInputHandle)id, center, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: setAccumulatorDeadband
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogJNI_setAccumulatorDeadband
(JNIEnv* env, jclass, jint id, jint deadband)
{
int32_t status = 0;
HAL_SetAccumulatorDeadband((HAL_AnalogInputHandle)id, deadband, &status);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: getAccumulatorValue
* Signature: (I)J
*/
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_hal_AnalogJNI_getAccumulatorValue
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jlong returnValue =
HAL_GetAccumulatorValue((HAL_AnalogInputHandle)id, &status);
CheckStatus(env, status);
return returnValue;
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: getAccumulatorCount
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_AnalogJNI_getAccumulatorCount
(JNIEnv* env, jclass, jint id)
{
int32_t status = 0;
jint returnValue =
HAL_GetAccumulatorCount((HAL_AnalogInputHandle)id, &status);
CheckStatus(env, status);
return returnValue;
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: getAccumulatorOutput
* Signature: (ILjava/lang/Object;)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_AnalogJNI_getAccumulatorOutput
(JNIEnv* env, jclass, jint id, jobject accumulatorResult)
{
int32_t status = 0;
int64_t value = 0;
int64_t count = 0;
HAL_GetAccumulatorOutput((HAL_AnalogInputHandle)id, &value, &count, &status);
SetAccumulatorResultObject(env, accumulatorResult, value, count);
CheckStatus(env, status);
}
/*
* Class: edu_wpi_first_hal_AnalogJNI
* Method: initializeAnalogTrigger

11
hal/src/main/native/cpp/jni/HALUtil.cpp
View File

@@ -51,7 +51,6 @@ static JClass powerDistributionVersionCls;
static JClass pwmConfigDataResultCls;
static JClass canStatusCls;
static JClass matchInfoDataCls;
static JClass accumulatorResultCls;
static JClass canDataCls;
static JClass canStreamMessageCls;
static JClass halValueCls;
@@ -65,7 +64,6 @@ static const JClassInit classes[] = {
{"edu/wpi/first/hal/PWMConfigDataResult", &pwmConfigDataResultCls},
{"edu/wpi/first/hal/can/CANStatus", &canStatusCls},
{"edu/wpi/first/hal/MatchInfoData", &matchInfoDataCls},
{"edu/wpi/first/hal/AccumulatorResult", &accumulatorResultCls},
{"edu/wpi/first/hal/CANData", &canDataCls},
{"edu/wpi/first/hal/CANStreamMessage", &canStreamMessageCls},
{"edu/wpi/first/hal/HALValue", &halValueCls},
@@ -306,15 +304,6 @@ void SetMatchInfoObject(JNIEnv* env, jobject matchStatus,
static_cast<jint>(matchInfo.matchType));
}
void SetAccumulatorResultObject(JNIEnv* env, jobject accumulatorResult,
int64_t value, int64_t count) {
static jmethodID func =
env->GetMethodID(accumulatorResultCls, "set", "(JJ)V");
env->CallVoidMethod(accumulatorResult, func, static_cast<jlong>(value),
static_cast<jlong>(count));
}
jbyteArray SetCANDataObject(JNIEnv* env, jobject canData, int32_t length,
uint64_t timestamp) {
static jmethodID func = env->GetMethodID(canDataCls, "setData", "(IJ)[B");

3
hal/src/main/native/cpp/jni/HALUtil.h
View File

@@ -75,9 +75,6 @@ void SetCanStatusObject(JNIEnv* env, jobject canStatus,
void SetMatchInfoObject(JNIEnv* env, jobject matchStatus,
const HAL_MatchInfo& matchInfo);
void SetAccumulatorResultObject(JNIEnv* env, jobject accumulatorResult,
int64_t value, int64_t count);
jbyteArray SetCANDataObject(JNIEnv* env, jobject canData, int32_t length,
uint64_t timestamp);

13
hal/src/main/native/cpp/jni/PortsJNI.cpp
View File

@@ -13,19 +13,6 @@
using namespace hal;
extern "C" {
/*
* Class: edu_wpi_first_hal_PortsJNI
* Method: getNumAccumulators
* Signature: ()I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_PortsJNI_getNumAccumulators
(JNIEnv* env, jclass)
{
jint value = HAL_GetNumAccumulators();
return value;
}
/*
* Class: edu_wpi_first_hal_PortsJNI
* Method: getNumAnalogTriggers

177
hal/src/main/native/cpp/jni/simulation/AnalogGyroDataJNI.cpp
View File

@@ -1,177 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
#include <jni.h>
#include "CallbackStore.h"
#include "edu_wpi_first_hal_simulation_AnalogGyroDataJNI.h"
#include "hal/simulation/AnalogGyroData.h"
using namespace hal;
extern "C" {
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: registerAngleCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_registerAngleCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(env, index, callback, initialNotify,
&HALSIM_RegisterAnalogGyroAngleCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: cancelAngleCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_cancelAngleCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogGyroAngleCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: getAngle
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_getAngle
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogGyroAngle(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: setAngle
* Signature: (ID)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_setAngle
(JNIEnv*, jclass, jint index, jdouble value)
{
HALSIM_SetAnalogGyroAngle(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: registerRateCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_registerRateCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(env, index, callback, initialNotify,
&HALSIM_RegisterAnalogGyroRateCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: cancelRateCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_cancelRateCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogGyroRateCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: getRate
* Signature: (I)D
*/
JNIEXPORT jdouble JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_getRate
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogGyroRate(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: setRate
* Signature: (ID)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_setRate
(JNIEnv*, jclass, jint index, jdouble value)
{
HALSIM_SetAnalogGyroRate(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: registerInitializedCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_registerInitializedCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(env, index, callback, initialNotify,
&HALSIM_RegisterAnalogGyroInitializedCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: cancelInitializedCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_cancelInitializedCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogGyroInitializedCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: getInitialized
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_getInitialized
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogGyroInitialized(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: setInitialized
* Signature: (IZ)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_setInitialized
(JNIEnv*, jclass, jint index, jboolean value)
{
HALSIM_SetAnalogGyroInitialized(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogGyroDataJNI
* Method: resetData
* Signature: (I)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogGyroDataJNI_resetData
(JNIEnv*, jclass, jint index)
{
HALSIM_ResetAnalogGyroData(index);
}
} // extern "C"

255
hal/src/main/native/cpp/jni/simulation/AnalogInDataJNI.cpp
View File

@@ -212,261 +212,6 @@ Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setVoltage
HALSIM_SetAnalogInVoltage(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: registerAccumulatorInitializedCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_registerAccumulatorInitializedCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(
env, index, callback, initialNotify,
&HALSIM_RegisterAnalogInAccumulatorInitializedCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: cancelAccumulatorInitializedCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_cancelAccumulatorInitializedCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(
env, handle, index, &HALSIM_CancelAnalogInAccumulatorInitializedCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: getAccumulatorInitialized
* Signature: (I)Z
*/
JNIEXPORT jboolean JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_getAccumulatorInitialized
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogInAccumulatorInitialized(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: setAccumulatorInitialized
* Signature: (IZ)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setAccumulatorInitialized
(JNIEnv*, jclass, jint index, jboolean value)
{
HALSIM_SetAnalogInAccumulatorInitialized(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: registerAccumulatorValueCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_registerAccumulatorValueCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(
env, index, callback, initialNotify,
&HALSIM_RegisterAnalogInAccumulatorValueCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: cancelAccumulatorValueCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_cancelAccumulatorValueCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogInAccumulatorValueCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: getAccumulatorValue
* Signature: (I)J
*/
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_getAccumulatorValue
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogInAccumulatorValue(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: setAccumulatorValue
* Signature: (IJ)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setAccumulatorValue
(JNIEnv*, jclass, jint index, jlong value)
{
HALSIM_SetAnalogInAccumulatorValue(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: registerAccumulatorCountCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_registerAccumulatorCountCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(
env, index, callback, initialNotify,
&HALSIM_RegisterAnalogInAccumulatorCountCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: cancelAccumulatorCountCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_cancelAccumulatorCountCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogInAccumulatorCountCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: getAccumulatorCount
* Signature: (I)J
*/
JNIEXPORT jlong JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_getAccumulatorCount
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogInAccumulatorCount(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: setAccumulatorCount
* Signature: (IJ)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setAccumulatorCount
(JNIEnv*, jclass, jint index, jlong value)
{
HALSIM_SetAnalogInAccumulatorCount(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: registerAccumulatorCenterCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_registerAccumulatorCenterCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(
env, index, callback, initialNotify,
&HALSIM_RegisterAnalogInAccumulatorCenterCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: cancelAccumulatorCenterCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_cancelAccumulatorCenterCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogInAccumulatorCenterCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: getAccumulatorCenter
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_getAccumulatorCenter
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogInAccumulatorCenter(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: setAccumulatorCenter
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setAccumulatorCenter
(JNIEnv*, jclass, jint index, jint value)
{
HALSIM_SetAnalogInAccumulatorCenter(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: registerAccumulatorDeadbandCallback
* Signature: (ILjava/lang/Object;Z)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_registerAccumulatorDeadbandCallback
(JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify)
{
return sim::AllocateCallback(
env, index, callback, initialNotify,
&HALSIM_RegisterAnalogInAccumulatorDeadbandCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: cancelAccumulatorDeadbandCallback
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_cancelAccumulatorDeadbandCallback
(JNIEnv* env, jclass, jint index, jint handle)
{
return sim::FreeCallback(env, handle, index,
&HALSIM_CancelAnalogInAccumulatorDeadbandCallback);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: getAccumulatorDeadband
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_getAccumulatorDeadband
(JNIEnv*, jclass, jint index)
{
return HALSIM_GetAnalogInAccumulatorDeadband(index);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: setAccumulatorDeadband
* Signature: (II)V
*/
JNIEXPORT void JNICALL
Java_edu_wpi_first_hal_simulation_AnalogInDataJNI_setAccumulatorDeadband
(JNIEnv*, jclass, jint index, jint value)
{
HALSIM_SetAnalogInAccumulatorDeadband(index, value);
}
/*
* Class: edu_wpi_first_hal_simulation_AnalogInDataJNI
* Method: resetData