diff --git a/hal/src/main/java/edu/wpi/first/hal/simulation/RoboRioDataJNI.java b/hal/src/main/java/edu/wpi/first/hal/simulation/RoboRioDataJNI.java index 63ebef0b95..a95abfe952 100644 --- a/hal/src/main/java/edu/wpi/first/hal/simulation/RoboRioDataJNI.java +++ b/hal/src/main/java/edu/wpi/first/hal/simulation/RoboRioDataJNI.java @@ -10,80 +10,80 @@ package edu.wpi.first.hal.simulation; import edu.wpi.first.hal.JNIWrapper; public class RoboRioDataJNI extends JNIWrapper { - public static native int registerFPGAButtonCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelFPGAButtonCallback(int index, int uid); - public static native boolean getFPGAButton(int index); - public static native void setFPGAButton(int index, boolean fPGAButton); + public static native int registerFPGAButtonCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelFPGAButtonCallback(int uid); + public static native boolean getFPGAButton(); + public static native void setFPGAButton(boolean fPGAButton); - public static native int registerVInVoltageCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelVInVoltageCallback(int index, int uid); - public static native double getVInVoltage(int index); - public static native void setVInVoltage(int index, double vInVoltage); + public static native int registerVInVoltageCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelVInVoltageCallback(int uid); + public static native double getVInVoltage(); + public static native void setVInVoltage(double vInVoltage); - public static native int registerVInCurrentCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelVInCurrentCallback(int index, int uid); - public static native double getVInCurrent(int index); - public static native void setVInCurrent(int index, double vInCurrent); + public static native int registerVInCurrentCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelVInCurrentCallback(int uid); + public static native double getVInCurrent(); + public static native void setVInCurrent(double vInCurrent); - public static native int registerUserVoltage6VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserVoltage6VCallback(int index, int uid); - public static native double getUserVoltage6V(int index); - public static native void setUserVoltage6V(int index, double userVoltage6V); + public static native int registerUserVoltage6VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage6VCallback(int uid); + public static native double getUserVoltage6V(); + public static native void setUserVoltage6V(double userVoltage6V); - public static native int registerUserCurrent6VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserCurrent6VCallback(int index, int uid); - public static native double getUserCurrent6V(int index); - public static native void setUserCurrent6V(int index, double userCurrent6V); + public static native int registerUserCurrent6VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent6VCallback(int uid); + public static native double getUserCurrent6V(); + public static native void setUserCurrent6V(double userCurrent6V); - public static native int registerUserActive6VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserActive6VCallback(int index, int uid); - public static native boolean getUserActive6V(int index); - public static native void setUserActive6V(int index, boolean userActive6V); + public static native int registerUserActive6VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive6VCallback(int uid); + public static native boolean getUserActive6V(); + public static native void setUserActive6V(boolean userActive6V); - public static native int registerUserVoltage5VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserVoltage5VCallback(int index, int uid); - public static native double getUserVoltage5V(int index); - public static native void setUserVoltage5V(int index, double userVoltage5V); + public static native int registerUserVoltage5VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage5VCallback(int uid); + public static native double getUserVoltage5V(); + public static native void setUserVoltage5V(double userVoltage5V); - public static native int registerUserCurrent5VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserCurrent5VCallback(int index, int uid); - public static native double getUserCurrent5V(int index); - public static native void setUserCurrent5V(int index, double userCurrent5V); + public static native int registerUserCurrent5VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent5VCallback(int uid); + public static native double getUserCurrent5V(); + public static native void setUserCurrent5V(double userCurrent5V); - public static native int registerUserActive5VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserActive5VCallback(int index, int uid); - public static native boolean getUserActive5V(int index); - public static native void setUserActive5V(int index, boolean userActive5V); + public static native int registerUserActive5VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive5VCallback(int uid); + public static native boolean getUserActive5V(); + public static native void setUserActive5V(boolean userActive5V); - public static native int registerUserVoltage3V3Callback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserVoltage3V3Callback(int index, int uid); - public static native double getUserVoltage3V3(int index); - public static native void setUserVoltage3V3(int index, double userVoltage3V3); + public static native int registerUserVoltage3V3Callback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserVoltage3V3Callback(int uid); + public static native double getUserVoltage3V3(); + public static native void setUserVoltage3V3(double userVoltage3V3); - public static native int registerUserCurrent3V3Callback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserCurrent3V3Callback(int index, int uid); - public static native double getUserCurrent3V3(int index); - public static native void setUserCurrent3V3(int index, double userCurrent3V3); + public static native int registerUserCurrent3V3Callback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserCurrent3V3Callback(int uid); + public static native double getUserCurrent3V3(); + public static native void setUserCurrent3V3(double userCurrent3V3); - public static native int registerUserActive3V3Callback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserActive3V3Callback(int index, int uid); - public static native boolean getUserActive3V3(int index); - public static native void setUserActive3V3(int index, boolean userActive3V3); + public static native int registerUserActive3V3Callback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserActive3V3Callback(int uid); + public static native boolean getUserActive3V3(); + public static native void setUserActive3V3(boolean userActive3V3); - public static native int registerUserFaults6VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserFaults6VCallback(int index, int uid); - public static native int getUserFaults6V(int index); - public static native void setUserFaults6V(int index, int userFaults6V); + public static native int registerUserFaults6VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults6VCallback(int uid); + public static native int getUserFaults6V(); + public static native void setUserFaults6V(int userFaults6V); - public static native int registerUserFaults5VCallback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserFaults5VCallback(int index, int uid); - public static native int getUserFaults5V(int index); - public static native void setUserFaults5V(int index, int userFaults5V); + public static native int registerUserFaults5VCallback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults5VCallback(int uid); + public static native int getUserFaults5V(); + public static native void setUserFaults5V(int userFaults5V); - public static native int registerUserFaults3V3Callback(int index, NotifyCallback callback, boolean initialNotify); - public static native void cancelUserFaults3V3Callback(int index, int uid); - public static native int getUserFaults3V3(int index); - public static native void setUserFaults3V3(int index, int userFaults3V3); + public static native int registerUserFaults3V3Callback(NotifyCallback callback, boolean initialNotify); + public static native void cancelUserFaults3V3Callback(int uid); + public static native int getUserFaults3V3(); + public static native void setUserFaults3V3(int userFaults3V3); - public static native void resetData(int index); + public static native void resetData(); } diff --git a/hal/src/main/native/include/hal/simulation/RoboRioData.h b/hal/src/main/native/include/hal/simulation/RoboRioData.h index 31cd60f96d..49d32f3437 100644 --- a/hal/src/main/native/include/hal/simulation/RoboRioData.h +++ b/hal/src/main/native/include/hal/simulation/RoboRioData.h @@ -14,127 +14,111 @@ extern "C" { #endif -void HALSIM_ResetRoboRioData(int32_t index); -int32_t HALSIM_RegisterRoboRioFPGAButtonCallback(int32_t index, - HAL_NotifyCallback callback, +void HALSIM_ResetRoboRioData(void); +int32_t HALSIM_RegisterRoboRioFPGAButtonCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioFPGAButtonCallback(int32_t index, int32_t uid); -HAL_Bool HALSIM_GetRoboRioFPGAButton(int32_t index); -void HALSIM_SetRoboRioFPGAButton(int32_t index, HAL_Bool fPGAButton); +void HALSIM_CancelRoboRioFPGAButtonCallback(int32_t uid); +HAL_Bool HALSIM_GetRoboRioFPGAButton(void); +void HALSIM_SetRoboRioFPGAButton(HAL_Bool fPGAButton); -int32_t HALSIM_RegisterRoboRioVInVoltageCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioVInVoltageCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioVInVoltageCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioVInVoltage(int32_t index); -void HALSIM_SetRoboRioVInVoltage(int32_t index, double vInVoltage); +void HALSIM_CancelRoboRioVInVoltageCallback(int32_t uid); +double HALSIM_GetRoboRioVInVoltage(void); +void HALSIM_SetRoboRioVInVoltage(double vInVoltage); -int32_t HALSIM_RegisterRoboRioVInCurrentCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioVInCurrentCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioVInCurrentCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioVInCurrent(int32_t index); -void HALSIM_SetRoboRioVInCurrent(int32_t index, double vInCurrent); +void HALSIM_CancelRoboRioVInCurrentCallback(int32_t uid); +double HALSIM_GetRoboRioVInCurrent(void); +void HALSIM_SetRoboRioVInCurrent(double vInCurrent); -int32_t HALSIM_RegisterRoboRioUserVoltage6VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserVoltage6VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserVoltage6VCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserVoltage6V(int32_t index); -void HALSIM_SetRoboRioUserVoltage6V(int32_t index, double userVoltage6V); +void HALSIM_CancelRoboRioUserVoltage6VCallback(int32_t uid); +double HALSIM_GetRoboRioUserVoltage6V(void); +void HALSIM_SetRoboRioUserVoltage6V(double userVoltage6V); -int32_t HALSIM_RegisterRoboRioUserCurrent6VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserCurrent6VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserCurrent6VCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserCurrent6V(int32_t index); -void HALSIM_SetRoboRioUserCurrent6V(int32_t index, double userCurrent6V); +void HALSIM_CancelRoboRioUserCurrent6VCallback(int32_t uid); +double HALSIM_GetRoboRioUserCurrent6V(void); +void HALSIM_SetRoboRioUserCurrent6V(double userCurrent6V); -int32_t HALSIM_RegisterRoboRioUserActive6VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserActive6VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserActive6VCallback(int32_t index, int32_t uid); -HAL_Bool HALSIM_GetRoboRioUserActive6V(int32_t index); -void HALSIM_SetRoboRioUserActive6V(int32_t index, HAL_Bool userActive6V); +void HALSIM_CancelRoboRioUserActive6VCallback(int32_t uid); +HAL_Bool HALSIM_GetRoboRioUserActive6V(void); +void HALSIM_SetRoboRioUserActive6V(HAL_Bool userActive6V); -int32_t HALSIM_RegisterRoboRioUserVoltage5VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserVoltage5VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserVoltage5VCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserVoltage5V(int32_t index); -void HALSIM_SetRoboRioUserVoltage5V(int32_t index, double userVoltage5V); +void HALSIM_CancelRoboRioUserVoltage5VCallback(int32_t uid); +double HALSIM_GetRoboRioUserVoltage5V(void); +void HALSIM_SetRoboRioUserVoltage5V(double userVoltage5V); -int32_t HALSIM_RegisterRoboRioUserCurrent5VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserCurrent5VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserCurrent5VCallback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserCurrent5V(int32_t index); -void HALSIM_SetRoboRioUserCurrent5V(int32_t index, double userCurrent5V); +void HALSIM_CancelRoboRioUserCurrent5VCallback(int32_t uid); +double HALSIM_GetRoboRioUserCurrent5V(void); +void HALSIM_SetRoboRioUserCurrent5V(double userCurrent5V); -int32_t HALSIM_RegisterRoboRioUserActive5VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserActive5VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserActive5VCallback(int32_t index, int32_t uid); -HAL_Bool HALSIM_GetRoboRioUserActive5V(int32_t index); -void HALSIM_SetRoboRioUserActive5V(int32_t index, HAL_Bool userActive5V); +void HALSIM_CancelRoboRioUserActive5VCallback(int32_t uid); +HAL_Bool HALSIM_GetRoboRioUserActive5V(void); +void HALSIM_SetRoboRioUserActive5V(HAL_Bool userActive5V); int32_t HALSIM_RegisterRoboRioUserVoltage3V3Callback( - int32_t index, HAL_NotifyCallback callback, void* param, - HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserVoltage3V3Callback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserVoltage3V3(int32_t index); -void HALSIM_SetRoboRioUserVoltage3V3(int32_t index, double userVoltage3V3); + HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); +void HALSIM_CancelRoboRioUserVoltage3V3Callback(int32_t uid); +double HALSIM_GetRoboRioUserVoltage3V3(void); +void HALSIM_SetRoboRioUserVoltage3V3(double userVoltage3V3); int32_t HALSIM_RegisterRoboRioUserCurrent3V3Callback( - int32_t index, HAL_NotifyCallback callback, void* param, - HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserCurrent3V3Callback(int32_t index, int32_t uid); -double HALSIM_GetRoboRioUserCurrent3V3(int32_t index); -void HALSIM_SetRoboRioUserCurrent3V3(int32_t index, double userCurrent3V3); + HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); +void HALSIM_CancelRoboRioUserCurrent3V3Callback(int32_t uid); +double HALSIM_GetRoboRioUserCurrent3V3(void); +void HALSIM_SetRoboRioUserCurrent3V3(double userCurrent3V3); -int32_t HALSIM_RegisterRoboRioUserActive3V3Callback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserActive3V3Callback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserActive3V3Callback(int32_t index, int32_t uid); -HAL_Bool HALSIM_GetRoboRioUserActive3V3(int32_t index); -void HALSIM_SetRoboRioUserActive3V3(int32_t index, HAL_Bool userActive3V3); +void HALSIM_CancelRoboRioUserActive3V3Callback(int32_t uid); +HAL_Bool HALSIM_GetRoboRioUserActive3V3(void); +void HALSIM_SetRoboRioUserActive3V3(HAL_Bool userActive3V3); -int32_t HALSIM_RegisterRoboRioUserFaults6VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserFaults6VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserFaults6VCallback(int32_t index, int32_t uid); -int32_t HALSIM_GetRoboRioUserFaults6V(int32_t index); -void HALSIM_SetRoboRioUserFaults6V(int32_t index, int32_t userFaults6V); +void HALSIM_CancelRoboRioUserFaults6VCallback(int32_t uid); +int32_t HALSIM_GetRoboRioUserFaults6V(void); +void HALSIM_SetRoboRioUserFaults6V(int32_t userFaults6V); -int32_t HALSIM_RegisterRoboRioUserFaults5VCallback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserFaults5VCallback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserFaults5VCallback(int32_t index, int32_t uid); -int32_t HALSIM_GetRoboRioUserFaults5V(int32_t index); -void HALSIM_SetRoboRioUserFaults5V(int32_t index, int32_t userFaults5V); +void HALSIM_CancelRoboRioUserFaults5VCallback(int32_t uid); +int32_t HALSIM_GetRoboRioUserFaults5V(void); +void HALSIM_SetRoboRioUserFaults5V(int32_t userFaults5V); -int32_t HALSIM_RegisterRoboRioUserFaults3V3Callback(int32_t index, - HAL_NotifyCallback callback, +int32_t HALSIM_RegisterRoboRioUserFaults3V3Callback(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); -void HALSIM_CancelRoboRioUserFaults3V3Callback(int32_t index, int32_t uid); -int32_t HALSIM_GetRoboRioUserFaults3V3(int32_t index); -void HALSIM_SetRoboRioUserFaults3V3(int32_t index, int32_t userFaults3V3); +void HALSIM_CancelRoboRioUserFaults3V3Callback(int32_t uid); +int32_t HALSIM_GetRoboRioUserFaults3V3(void); +void HALSIM_SetRoboRioUserFaults3V3(int32_t userFaults3V3); -void HALSIM_RegisterRoboRioAllCallbacks(int32_t index, - HAL_NotifyCallback callback, +void HALSIM_RegisterRoboRioAllCallbacks(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify); #ifdef __cplusplus diff --git a/hal/src/main/native/sim/Power.cpp b/hal/src/main/native/sim/Power.cpp index 95bb3dd05a..e8ce7103cc 100644 --- a/hal/src/main/native/sim/Power.cpp +++ b/hal/src/main/native/sim/Power.cpp @@ -1,5 +1,5 @@ /*----------------------------------------------------------------------------*/ -/* Copyright (c) 2017-2018 FIRST. All Rights Reserved. */ +/* Copyright (c) 2017-2020 FIRST. All Rights Reserved. */ /* Open Source Software - may be modified and shared by FRC teams. The code */ /* must be accompanied by the FIRST BSD license file in the root directory of */ /* the project. */ @@ -19,46 +19,42 @@ void InitializePower() {} // TODO: Fix the naming in here extern "C" { -double HAL_GetVinVoltage(int32_t* status) { - return SimRoboRioData[0].vInVoltage; -} -double HAL_GetVinCurrent(int32_t* status) { - return SimRoboRioData[0].vInCurrent; -} +double HAL_GetVinVoltage(int32_t* status) { return SimRoboRioData->vInVoltage; } +double HAL_GetVinCurrent(int32_t* status) { return SimRoboRioData->vInCurrent; } double HAL_GetUserVoltage6V(int32_t* status) { - return SimRoboRioData[0].userVoltage6V; + return SimRoboRioData->userVoltage6V; } double HAL_GetUserCurrent6V(int32_t* status) { - return SimRoboRioData[0].userCurrent6V; + return SimRoboRioData->userCurrent6V; } HAL_Bool HAL_GetUserActive6V(int32_t* status) { - return SimRoboRioData[0].userActive6V; + return SimRoboRioData->userActive6V; } int32_t HAL_GetUserCurrentFaults6V(int32_t* status) { - return SimRoboRioData[0].userFaults6V; + return SimRoboRioData->userFaults6V; } double HAL_GetUserVoltage5V(int32_t* status) { - return SimRoboRioData[0].userVoltage5V; + return SimRoboRioData->userVoltage5V; } double HAL_GetUserCurrent5V(int32_t* status) { - return SimRoboRioData[0].userCurrent5V; + return SimRoboRioData->userCurrent5V; } HAL_Bool HAL_GetUserActive5V(int32_t* status) { - return SimRoboRioData[0].userActive5V; + return SimRoboRioData->userActive5V; } int32_t HAL_GetUserCurrentFaults5V(int32_t* status) { - return SimRoboRioData[0].userFaults5V; + return SimRoboRioData->userFaults5V; } double HAL_GetUserVoltage3V3(int32_t* status) { - return SimRoboRioData[0].userVoltage3V3; + return SimRoboRioData->userVoltage3V3; } double HAL_GetUserCurrent3V3(int32_t* status) { - return SimRoboRioData[0].userCurrent3V3; + return SimRoboRioData->userCurrent3V3; } HAL_Bool HAL_GetUserActive3V3(int32_t* status) { - return SimRoboRioData[0].userActive3V3; + return SimRoboRioData->userActive3V3; } int32_t HAL_GetUserCurrentFaults3V3(int32_t* status) { - return SimRoboRioData[0].userFaults3V3; + return SimRoboRioData->userFaults3V3; } } // extern "C" diff --git a/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp b/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp index 484821b3e8..1ff6044de5 100644 --- a/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp +++ b/hal/src/main/native/sim/jni/RoboRioDataJNI.cpp @@ -18,763 +18,775 @@ extern "C" { /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerFPGAButtonCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerFPGAButtonCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioFPGAButtonCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, &HALSIM_RegisterRoboRioFPGAButtonCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelFPGAButtonCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelFPGAButtonCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioFPGAButtonCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioFPGAButtonCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getFPGAButton - * Signature: (I)Z + * Signature: ()Z */ JNIEXPORT jboolean JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getFPGAButton - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioFPGAButton(index); + return HALSIM_GetRoboRioFPGAButton(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setFPGAButton - * Signature: (IZ)V + * Signature: (Z)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setFPGAButton - (JNIEnv*, jclass, jint index, jboolean value) + (JNIEnv*, jclass, jboolean value) { - HALSIM_SetRoboRioFPGAButton(index, value); + HALSIM_SetRoboRioFPGAButton(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerVInVoltageCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerVInVoltageCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioVInVoltageCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, &HALSIM_RegisterRoboRioVInVoltageCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelVInVoltageCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelVInVoltageCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioVInVoltageCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioVInVoltageCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getVInVoltage - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getVInVoltage - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioVInVoltage(index); + return HALSIM_GetRoboRioVInVoltage(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setVInVoltage - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setVInVoltage - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioVInVoltage(index, value); + HALSIM_SetRoboRioVInVoltage(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerVInCurrentCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerVInCurrentCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioVInCurrentCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, &HALSIM_RegisterRoboRioVInCurrentCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelVInCurrentCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelVInCurrentCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioVInCurrentCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioVInCurrentCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getVInCurrent - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getVInCurrent - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioVInCurrent(index); + return HALSIM_GetRoboRioVInCurrent(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setVInCurrent - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setVInCurrent - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioVInCurrent(index, value); + HALSIM_SetRoboRioVInCurrent(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserVoltage6VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserVoltage6VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserVoltage6VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserVoltage6VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserVoltage6VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserVoltage6VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserVoltage6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserVoltage6V - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserVoltage6V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserVoltage6V(index); + return HALSIM_GetRoboRioUserVoltage6V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserVoltage6V - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserVoltage6V - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserVoltage6V(index, value); + HALSIM_SetRoboRioUserVoltage6V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserCurrent6VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserCurrent6VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserCurrent6VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserCurrent6VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserCurrent6VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserCurrent6VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserCurrent6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserCurrent6V - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserCurrent6V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserCurrent6V(index); + return HALSIM_GetRoboRioUserCurrent6V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserCurrent6V - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserCurrent6V - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserCurrent6V(index, value); + HALSIM_SetRoboRioUserCurrent6V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserActive6VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserActive6VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserActive6VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserActive6VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserActive6VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserActive6VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserActive6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserActive6V - * Signature: (I)Z + * Signature: ()Z */ JNIEXPORT jboolean JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserActive6V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserActive6V(index); + return HALSIM_GetRoboRioUserActive6V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserActive6V - * Signature: (IZ)V + * Signature: (Z)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserActive6V - (JNIEnv*, jclass, jint index, jboolean value) + (JNIEnv*, jclass, jboolean value) { - HALSIM_SetRoboRioUserActive6V(index, value); + HALSIM_SetRoboRioUserActive6V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserVoltage5VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserVoltage5VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserVoltage5VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserVoltage5VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserVoltage5VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserVoltage5VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserVoltage5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserVoltage5V - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserVoltage5V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserVoltage5V(index); + return HALSIM_GetRoboRioUserVoltage5V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserVoltage5V - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserVoltage5V - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserVoltage5V(index, value); + HALSIM_SetRoboRioUserVoltage5V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserCurrent5VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserCurrent5VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserCurrent5VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserCurrent5VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserCurrent5VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserCurrent5VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserCurrent5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserCurrent5V - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserCurrent5V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserCurrent5V(index); + return HALSIM_GetRoboRioUserCurrent5V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserCurrent5V - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserCurrent5V - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserCurrent5V(index, value); + HALSIM_SetRoboRioUserCurrent5V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserActive5VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserActive5VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserActive5VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserActive5VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserActive5VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserActive5VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserActive5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserActive5V - * Signature: (I)Z + * Signature: ()Z */ JNIEXPORT jboolean JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserActive5V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserActive5V(index); + return HALSIM_GetRoboRioUserActive5V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserActive5V - * Signature: (IZ)V + * Signature: (Z)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserActive5V - (JNIEnv*, jclass, jint index, jboolean value) + (JNIEnv*, jclass, jboolean value) { - HALSIM_SetRoboRioUserActive5V(index, value); + HALSIM_SetRoboRioUserActive5V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserVoltage3V3Callback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserVoltage3V3Callback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserVoltage3V3Callback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserVoltage3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserVoltage3V3Callback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserVoltage3V3Callback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserVoltage3V3Callback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserVoltage3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserVoltage3V3 - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserVoltage3V3 - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserVoltage3V3(index); + return HALSIM_GetRoboRioUserVoltage3V3(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserVoltage3V3 - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserVoltage3V3 - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserVoltage3V3(index, value); + HALSIM_SetRoboRioUserVoltage3V3(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserCurrent3V3Callback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserCurrent3V3Callback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserCurrent3V3Callback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserCurrent3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserCurrent3V3Callback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserCurrent3V3Callback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserCurrent3V3Callback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserCurrent3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserCurrent3V3 - * Signature: (I)D + * Signature: ()D */ JNIEXPORT jdouble JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserCurrent3V3 - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserCurrent3V3(index); + return HALSIM_GetRoboRioUserCurrent3V3(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserCurrent3V3 - * Signature: (ID)V + * Signature: (D)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserCurrent3V3 - (JNIEnv*, jclass, jint index, jdouble value) + (JNIEnv*, jclass, jdouble value) { - HALSIM_SetRoboRioUserCurrent3V3(index, value); + HALSIM_SetRoboRioUserCurrent3V3(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserActive3V3Callback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserActive3V3Callback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserActive3V3Callback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserActive3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserActive3V3Callback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserActive3V3Callback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserActive3V3Callback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserActive3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserActive3V3 - * Signature: (I)Z + * Signature: ()Z */ JNIEXPORT jboolean JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserActive3V3 - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserActive3V3(index); + return HALSIM_GetRoboRioUserActive3V3(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserActive3V3 - * Signature: (IZ)V + * Signature: (Z)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserActive3V3 - (JNIEnv*, jclass, jint index, jboolean value) + (JNIEnv*, jclass, jboolean value) { - HALSIM_SetRoboRioUserActive3V3(index, value); + HALSIM_SetRoboRioUserActive3V3(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserFaults6VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserFaults6VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserFaults6VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserFaults6VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserFaults6VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserFaults6VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserFaults6VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserFaults6V - * Signature: (I)I + * Signature: ()I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserFaults6V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserFaults6V(index); + return HALSIM_GetRoboRioUserFaults6V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserFaults6V - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserFaults6V - (JNIEnv*, jclass, jint index, jint value) + (JNIEnv*, jclass, jint value) { - HALSIM_SetRoboRioUserFaults6V(index, value); + HALSIM_SetRoboRioUserFaults6V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserFaults5VCallback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserFaults5VCallback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserFaults5VCallback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserFaults5VCallback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserFaults5VCallback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserFaults5VCallback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserFaults5VCallback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserFaults5V - * Signature: (I)I + * Signature: ()I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserFaults5V - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserFaults5V(index); + return HALSIM_GetRoboRioUserFaults5V(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserFaults5V - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserFaults5V - (JNIEnv*, jclass, jint index, jint value) + (JNIEnv*, jclass, jint value) { - HALSIM_SetRoboRioUserFaults5V(index, value); + HALSIM_SetRoboRioUserFaults5V(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: registerUserFaults3V3Callback - * Signature: (ILjava/lang/Object;Z)I + * Signature: (Ljava/lang/Object;Z)I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_registerUserFaults3V3Callback - (JNIEnv* env, jclass, jint index, jobject callback, jboolean initialNotify) + (JNIEnv* env, jclass, jobject callback, jboolean initialNotify) { - return sim::AllocateCallback(env, index, callback, initialNotify, - &HALSIM_RegisterRoboRioUserFaults3V3Callback); + return sim::AllocateCallbackNoIndex( + env, callback, initialNotify, + &HALSIM_RegisterRoboRioUserFaults3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: cancelUserFaults3V3Callback - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_cancelUserFaults3V3Callback - (JNIEnv* env, jclass, jint index, jint handle) + (JNIEnv* env, jclass, jint handle) { - return sim::FreeCallback(env, handle, index, - &HALSIM_CancelRoboRioUserFaults3V3Callback); + return sim::FreeCallbackNoIndex(env, handle, + &HALSIM_CancelRoboRioUserFaults3V3Callback); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: getUserFaults3V3 - * Signature: (I)I + * Signature: ()I */ JNIEXPORT jint JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_getUserFaults3V3 - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - return HALSIM_GetRoboRioUserFaults3V3(index); + return HALSIM_GetRoboRioUserFaults3V3(); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: setUserFaults3V3 - * Signature: (II)V + * Signature: (I)V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_setUserFaults3V3 - (JNIEnv*, jclass, jint index, jint value) + (JNIEnv*, jclass, jint value) { - HALSIM_SetRoboRioUserFaults3V3(index, value); + HALSIM_SetRoboRioUserFaults3V3(value); } /* * Class: edu_wpi_first_hal_simulation_RoboRioDataJNI * Method: resetData - * Signature: (I)V + * Signature: ()V */ JNIEXPORT void JNICALL Java_edu_wpi_first_hal_simulation_RoboRioDataJNI_resetData - (JNIEnv*, jclass, jint index) + (JNIEnv*, jclass) { - HALSIM_ResetRoboRioData(index); + HALSIM_ResetRoboRioData(); } } // extern "C" diff --git a/hal/src/main/native/sim/mockdata/RoboRioData.cpp b/hal/src/main/native/sim/mockdata/RoboRioData.cpp index bab29d681a..76406f5a4f 100644 --- a/hal/src/main/native/sim/mockdata/RoboRioData.cpp +++ b/hal/src/main/native/sim/mockdata/RoboRioData.cpp @@ -13,8 +13,8 @@ using namespace hal; namespace hal { namespace init { void InitializeRoboRioData() { - static RoboRioData srrd[1]; - ::hal::SimRoboRioData = srrd; + static RoboRioData srrd; + ::hal::SimRoboRioData = &srrd; } } // namespace init } // namespace hal @@ -39,13 +39,11 @@ void RoboRioData::ResetData() { } extern "C" { -void HALSIM_ResetRoboRioData(int32_t index) { - SimRoboRioData[index].ResetData(); -} +void HALSIM_ResetRoboRioData(void) { SimRoboRioData->ResetData(); } -#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \ - HAL_SIMDATAVALUE_DEFINE_CAPI(TYPE, HALSIM, RoboRio##CAPINAME, \ - SimRoboRioData, LOWERNAME) +#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \ + HAL_SIMDATAVALUE_DEFINE_CAPI_NOINDEX(TYPE, HALSIM, RoboRio##CAPINAME, \ + SimRoboRioData, LOWERNAME) DEFINE_CAPI(HAL_Bool, FPGAButton, fpgaButton) DEFINE_CAPI(double, VInVoltage, vInVoltage) @@ -64,10 +62,9 @@ DEFINE_CAPI(int32_t, UserFaults5V, userFaults5V) DEFINE_CAPI(int32_t, UserFaults3V3, userFaults3V3) #define REGISTER(NAME) \ - SimRoboRioData[index].NAME.RegisterCallback(callback, param, initialNotify) + SimRoboRioData->NAME.RegisterCallback(callback, param, initialNotify) -void HALSIM_RegisterRoboRioAllCallbacks(int32_t index, - HAL_NotifyCallback callback, +void HALSIM_RegisterRoboRioAllCallbacks(HAL_NotifyCallback callback, void* param, HAL_Bool initialNotify) { REGISTER(fpgaButton); REGISTER(vInVoltage); diff --git a/simulation/halsim_gui/src/main/native/cpp/RoboRioGui.cpp b/simulation/halsim_gui/src/main/native/cpp/RoboRioGui.cpp index eab4a2311e..d7435f21a5 100644 --- a/simulation/halsim_gui/src/main/native/cpp/RoboRioGui.cpp +++ b/simulation/halsim_gui/src/main/native/cpp/RoboRioGui.cpp @@ -16,102 +16,99 @@ using namespace halsimgui; static void DisplayRoboRio() { ImGui::Button("User Button"); - HALSIM_SetRoboRioFPGAButton(0, ImGui::IsItemActive()); + HALSIM_SetRoboRioFPGAButton(ImGui::IsItemActive()); ImGui::PushItemWidth(ImGui::GetFontSize() * 8); if (ImGui::CollapsingHeader("RoboRIO Input")) { { - double val = HALSIM_GetRoboRioVInVoltage(0); + double val = HALSIM_GetRoboRioVInVoltage(); if (ImGui::InputDouble("Voltage (V)", &val)) - HALSIM_SetRoboRioVInVoltage(0, val); + HALSIM_SetRoboRioVInVoltage(val); } { - double val = HALSIM_GetRoboRioVInCurrent(0); + double val = HALSIM_GetRoboRioVInCurrent(); if (ImGui::InputDouble("Current (A)", &val)) - HALSIM_SetRoboRioVInCurrent(0, val); + HALSIM_SetRoboRioVInCurrent(val); } } if (ImGui::CollapsingHeader("6V Rail")) { { - double val = HALSIM_GetRoboRioUserVoltage6V(0); + double val = HALSIM_GetRoboRioUserVoltage6V(); if (ImGui::InputDouble("Voltage (V)", &val)) - HALSIM_SetRoboRioUserVoltage6V(0, val); + HALSIM_SetRoboRioUserVoltage6V(val); } { - double val = HALSIM_GetRoboRioUserCurrent6V(0); + double val = HALSIM_GetRoboRioUserCurrent6V(); if (ImGui::InputDouble("Current (A)", &val)) - HALSIM_SetRoboRioUserCurrent6V(0, val); + HALSIM_SetRoboRioUserCurrent6V(val); } { static const char* options[] = {"inactive", "active"}; - int val = HALSIM_GetRoboRioUserActive6V(0) ? 1 : 0; + int val = HALSIM_GetRoboRioUserActive6V() ? 1 : 0; if (ImGui::Combo("Active", &val, options, 2)) - HALSIM_SetRoboRioUserActive6V(0, val); + HALSIM_SetRoboRioUserActive6V(val); } { - int val = HALSIM_GetRoboRioUserFaults6V(0); - if (ImGui::InputInt("Faults", &val)) - HALSIM_SetRoboRioUserFaults6V(0, val); + int val = HALSIM_GetRoboRioUserFaults6V(); + if (ImGui::InputInt("Faults", &val)) HALSIM_SetRoboRioUserFaults6V(val); } } if (ImGui::CollapsingHeader("5V Rail")) { { - double val = HALSIM_GetRoboRioUserVoltage5V(0); + double val = HALSIM_GetRoboRioUserVoltage5V(); if (ImGui::InputDouble("Voltage (V)", &val)) - HALSIM_SetRoboRioUserVoltage5V(0, val); + HALSIM_SetRoboRioUserVoltage5V(val); } { - double val = HALSIM_GetRoboRioUserCurrent5V(0); + double val = HALSIM_GetRoboRioUserCurrent5V(); if (ImGui::InputDouble("Current (A)", &val)) - HALSIM_SetRoboRioUserCurrent5V(0, val); + HALSIM_SetRoboRioUserCurrent5V(val); } { static const char* options[] = {"inactive", "active"}; - int val = HALSIM_GetRoboRioUserActive5V(0) ? 1 : 0; + int val = HALSIM_GetRoboRioUserActive5V() ? 1 : 0; if (ImGui::Combo("Active", &val, options, 2)) - HALSIM_SetRoboRioUserActive5V(0, val); + HALSIM_SetRoboRioUserActive5V(val); } { - int val = HALSIM_GetRoboRioUserFaults5V(0); - if (ImGui::InputInt("Faults", &val)) - HALSIM_SetRoboRioUserFaults5V(0, val); + int val = HALSIM_GetRoboRioUserFaults5V(); + if (ImGui::InputInt("Faults", &val)) HALSIM_SetRoboRioUserFaults5V(val); } } if (ImGui::CollapsingHeader("3.3V Rail")) { { - double val = HALSIM_GetRoboRioUserVoltage3V3(0); + double val = HALSIM_GetRoboRioUserVoltage3V3(); if (ImGui::InputDouble("Voltage (V)", &val)) - HALSIM_SetRoboRioUserVoltage3V3(0, val); + HALSIM_SetRoboRioUserVoltage3V3(val); } { - double val = HALSIM_GetRoboRioUserCurrent3V3(0); + double val = HALSIM_GetRoboRioUserCurrent3V3(); if (ImGui::InputDouble("Current (A)", &val)) - HALSIM_SetRoboRioUserCurrent3V3(0, val); + HALSIM_SetRoboRioUserCurrent3V3(val); } { static const char* options[] = {"inactive", "active"}; - int val = HALSIM_GetRoboRioUserActive3V3(0) ? 1 : 0; + int val = HALSIM_GetRoboRioUserActive3V3() ? 1 : 0; if (ImGui::Combo("Active", &val, options, 2)) - HALSIM_SetRoboRioUserActive3V3(0, val); + HALSIM_SetRoboRioUserActive3V3(val); } { - int val = HALSIM_GetRoboRioUserFaults3V3(0); - if (ImGui::InputInt("Faults", &val)) - HALSIM_SetRoboRioUserFaults3V3(0, val); + int val = HALSIM_GetRoboRioUserFaults3V3(); + if (ImGui::InputInt("Faults", &val)) HALSIM_SetRoboRioUserFaults3V3(val); } } diff --git a/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h b/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h index e04e5b428f..12db613ff8 100644 --- a/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h +++ b/wpilibc/src/main/native/include/frc/simulation/RoboRioSim.h @@ -16,259 +16,242 @@ namespace frc { namespace sim { + +/** + * Class to control a simulated RoboRIO. + */ class RoboRioSim { public: - explicit RoboRioSim(int index) { m_index = index; } - - std::unique_ptr RegisterFPGAButtonCallback( + static std::unique_ptr RegisterFPGAButtonCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioFPGAButtonCallback); + -1, callback, &HALSIM_CancelRoboRioFPGAButtonCallback); store->SetUid(HALSIM_RegisterRoboRioFPGAButtonCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - bool GetFPGAButton() const { return HALSIM_GetRoboRioFPGAButton(m_index); } + static bool GetFPGAButton() { return HALSIM_GetRoboRioFPGAButton(); } - void SetFPGAButton(bool fPGAButton) { - HALSIM_SetRoboRioFPGAButton(m_index, fPGAButton); + static void SetFPGAButton(bool fPGAButton) { + HALSIM_SetRoboRioFPGAButton(fPGAButton); } - std::unique_ptr RegisterVInVoltageCallback( + static std::unique_ptr RegisterVInVoltageCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioVInVoltageCallback); + -1, callback, &HALSIM_CancelRoboRioVInVoltageCallback); store->SetUid(HALSIM_RegisterRoboRioVInVoltageCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetVInVoltage() const { return HALSIM_GetRoboRioVInVoltage(m_index); } + static double GetVInVoltage() { return HALSIM_GetRoboRioVInVoltage(); } - void SetVInVoltage(double vInVoltage) { - HALSIM_SetRoboRioVInVoltage(m_index, vInVoltage); + static void SetVInVoltage(double vInVoltage) { + HALSIM_SetRoboRioVInVoltage(vInVoltage); } - std::unique_ptr RegisterVInCurrentCallback( + static std::unique_ptr RegisterVInCurrentCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioVInCurrentCallback); + -1, callback, &HALSIM_CancelRoboRioVInCurrentCallback); store->SetUid(HALSIM_RegisterRoboRioVInCurrentCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetVInCurrent() const { return HALSIM_GetRoboRioVInCurrent(m_index); } + static double GetVInCurrent() { return HALSIM_GetRoboRioVInCurrent(); } - void SetVInCurrent(double vInCurrent) { - HALSIM_SetRoboRioVInCurrent(m_index, vInCurrent); + static void SetVInCurrent(double vInCurrent) { + HALSIM_SetRoboRioVInCurrent(vInCurrent); } - std::unique_ptr RegisterUserVoltage6VCallback( + static std::unique_ptr RegisterUserVoltage6VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage6VCallback); + -1, callback, &HALSIM_CancelRoboRioUserVoltage6VCallback); store->SetUid(HALSIM_RegisterRoboRioUserVoltage6VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserVoltage6V() const { - return HALSIM_GetRoboRioUserVoltage6V(m_index); + static double GetUserVoltage6V() { return HALSIM_GetRoboRioUserVoltage6V(); } + + static void SetUserVoltage6V(double userVoltage6V) { + HALSIM_SetRoboRioUserVoltage6V(userVoltage6V); } - void SetUserVoltage6V(double userVoltage6V) { - HALSIM_SetRoboRioUserVoltage6V(m_index, userVoltage6V); - } - - std::unique_ptr RegisterUserCurrent6VCallback( + static std::unique_ptr RegisterUserCurrent6VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent6VCallback); + -1, callback, &HALSIM_CancelRoboRioUserCurrent6VCallback); store->SetUid(HALSIM_RegisterRoboRioUserCurrent6VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserCurrent6V() const { - return HALSIM_GetRoboRioUserCurrent6V(m_index); + static double GetUserCurrent6V() { return HALSIM_GetRoboRioUserCurrent6V(); } + + static void SetUserCurrent6V(double userCurrent6V) { + HALSIM_SetRoboRioUserCurrent6V(userCurrent6V); } - void SetUserCurrent6V(double userCurrent6V) { - HALSIM_SetRoboRioUserCurrent6V(m_index, userCurrent6V); - } - - std::unique_ptr RegisterUserActive6VCallback( + static std::unique_ptr RegisterUserActive6VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserActive6VCallback); + -1, callback, &HALSIM_CancelRoboRioUserActive6VCallback); store->SetUid(HALSIM_RegisterRoboRioUserActive6VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - bool GetUserActive6V() const { - return HALSIM_GetRoboRioUserActive6V(m_index); + static bool GetUserActive6V() { return HALSIM_GetRoboRioUserActive6V(); } + + static void SetUserActive6V(bool userActive6V) { + HALSIM_SetRoboRioUserActive6V(userActive6V); } - void SetUserActive6V(bool userActive6V) { - HALSIM_SetRoboRioUserActive6V(m_index, userActive6V); - } - - std::unique_ptr RegisterUserVoltage5VCallback( + static std::unique_ptr RegisterUserVoltage5VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage5VCallback); + -1, callback, &HALSIM_CancelRoboRioUserVoltage5VCallback); store->SetUid(HALSIM_RegisterRoboRioUserVoltage5VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserVoltage5V() const { - return HALSIM_GetRoboRioUserVoltage5V(m_index); + static double GetUserVoltage5V() { return HALSIM_GetRoboRioUserVoltage5V(); } + + static void SetUserVoltage5V(double userVoltage5V) { + HALSIM_SetRoboRioUserVoltage5V(userVoltage5V); } - void SetUserVoltage5V(double userVoltage5V) { - HALSIM_SetRoboRioUserVoltage5V(m_index, userVoltage5V); - } - - std::unique_ptr RegisterUserCurrent5VCallback( + static std::unique_ptr RegisterUserCurrent5VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent5VCallback); + -1, callback, &HALSIM_CancelRoboRioUserCurrent5VCallback); store->SetUid(HALSIM_RegisterRoboRioUserCurrent5VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserCurrent5V() const { - return HALSIM_GetRoboRioUserCurrent5V(m_index); + static double GetUserCurrent5V() { return HALSIM_GetRoboRioUserCurrent5V(); } + + static void SetUserCurrent5V(double userCurrent5V) { + HALSIM_SetRoboRioUserCurrent5V(userCurrent5V); } - void SetUserCurrent5V(double userCurrent5V) { - HALSIM_SetRoboRioUserCurrent5V(m_index, userCurrent5V); - } - - std::unique_ptr RegisterUserActive5VCallback( + static std::unique_ptr RegisterUserActive5VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserActive5VCallback); + -1, callback, &HALSIM_CancelRoboRioUserActive5VCallback); store->SetUid(HALSIM_RegisterRoboRioUserActive5VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - bool GetUserActive5V() const { - return HALSIM_GetRoboRioUserActive5V(m_index); + static bool GetUserActive5V() { return HALSIM_GetRoboRioUserActive5V(); } + + static void SetUserActive5V(bool userActive5V) { + HALSIM_SetRoboRioUserActive5V(userActive5V); } - void SetUserActive5V(bool userActive5V) { - HALSIM_SetRoboRioUserActive5V(m_index, userActive5V); - } - - std::unique_ptr RegisterUserVoltage3V3Callback( + static std::unique_ptr RegisterUserVoltage3V3Callback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserVoltage3V3Callback); + -1, callback, &HALSIM_CancelRoboRioUserVoltage3V3Callback); store->SetUid(HALSIM_RegisterRoboRioUserVoltage3V3Callback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserVoltage3V3() const { - return HALSIM_GetRoboRioUserVoltage3V3(m_index); + static double GetUserVoltage3V3() { + return HALSIM_GetRoboRioUserVoltage3V3(); } - void SetUserVoltage3V3(double userVoltage3V3) { - HALSIM_SetRoboRioUserVoltage3V3(m_index, userVoltage3V3); + static void SetUserVoltage3V3(double userVoltage3V3) { + HALSIM_SetRoboRioUserVoltage3V3(userVoltage3V3); } - std::unique_ptr RegisterUserCurrent3V3Callback( + static std::unique_ptr RegisterUserCurrent3V3Callback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserCurrent3V3Callback); + -1, callback, &HALSIM_CancelRoboRioUserCurrent3V3Callback); store->SetUid(HALSIM_RegisterRoboRioUserCurrent3V3Callback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - double GetUserCurrent3V3() const { - return HALSIM_GetRoboRioUserCurrent3V3(m_index); + static double GetUserCurrent3V3() { + return HALSIM_GetRoboRioUserCurrent3V3(); } - void SetUserCurrent3V3(double userCurrent3V3) { - HALSIM_SetRoboRioUserCurrent3V3(m_index, userCurrent3V3); + static void SetUserCurrent3V3(double userCurrent3V3) { + HALSIM_SetRoboRioUserCurrent3V3(userCurrent3V3); } - std::unique_ptr RegisterUserActive3V3Callback( + static std::unique_ptr RegisterUserActive3V3Callback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserActive3V3Callback); + -1, callback, &HALSIM_CancelRoboRioUserActive3V3Callback); store->SetUid(HALSIM_RegisterRoboRioUserActive3V3Callback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - bool GetUserActive3V3() const { - return HALSIM_GetRoboRioUserActive3V3(m_index); + static bool GetUserActive3V3() { return HALSIM_GetRoboRioUserActive3V3(); } + + static void SetUserActive3V3(bool userActive3V3) { + HALSIM_SetRoboRioUserActive3V3(userActive3V3); } - void SetUserActive3V3(bool userActive3V3) { - HALSIM_SetRoboRioUserActive3V3(m_index, userActive3V3); - } - - std::unique_ptr RegisterUserFaults6VCallback( + static std::unique_ptr RegisterUserFaults6VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults6VCallback); + -1, callback, &HALSIM_CancelRoboRioUserFaults6VCallback); store->SetUid(HALSIM_RegisterRoboRioUserFaults6VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - int GetUserFaults6V() const { return HALSIM_GetRoboRioUserFaults6V(m_index); } + static int GetUserFaults6V() { return HALSIM_GetRoboRioUserFaults6V(); } - void SetUserFaults6V(int userFaults6V) { - HALSIM_SetRoboRioUserFaults6V(m_index, userFaults6V); + static void SetUserFaults6V(int userFaults6V) { + HALSIM_SetRoboRioUserFaults6V(userFaults6V); } - std::unique_ptr RegisterUserFaults5VCallback( + static std::unique_ptr RegisterUserFaults5VCallback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults5VCallback); + -1, callback, &HALSIM_CancelRoboRioUserFaults5VCallback); store->SetUid(HALSIM_RegisterRoboRioUserFaults5VCallback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - int GetUserFaults5V() const { return HALSIM_GetRoboRioUserFaults5V(m_index); } + static int GetUserFaults5V() { return HALSIM_GetRoboRioUserFaults5V(); } - void SetUserFaults5V(int userFaults5V) { - HALSIM_SetRoboRioUserFaults5V(m_index, userFaults5V); + static void SetUserFaults5V(int userFaults5V) { + HALSIM_SetRoboRioUserFaults5V(userFaults5V); } - std::unique_ptr RegisterUserFaults3V3Callback( + static std::unique_ptr RegisterUserFaults3V3Callback( NotifyCallback callback, bool initialNotify) { auto store = std::make_unique( - m_index, -1, callback, &HALSIM_CancelRoboRioUserFaults3V3Callback); + -1, callback, &HALSIM_CancelRoboRioUserFaults3V3Callback); store->SetUid(HALSIM_RegisterRoboRioUserFaults3V3Callback( - m_index, &CallbackStoreThunk, store.get(), initialNotify)); + &CallbackStoreThunk, store.get(), initialNotify)); return store; } - int GetUserFaults3V3() const { - return HALSIM_GetRoboRioUserFaults3V3(m_index); + static int GetUserFaults3V3() { return HALSIM_GetRoboRioUserFaults3V3(); } + + static void SetUserFaults3V3(int userFaults3V3) { + HALSIM_SetRoboRioUserFaults3V3(userFaults3V3); } - void SetUserFaults3V3(int userFaults3V3) { - HALSIM_SetRoboRioUserFaults3V3(m_index, userFaults3V3); - } - - void ResetData() { HALSIM_ResetRoboRioData(m_index); } - - private: - int m_index; + static void ResetData() { HALSIM_ResetRoboRioData(); } }; } // namespace sim } // namespace frc diff --git a/wpilibc/src/test/native/cpp/simulation/SimInitializationTest.cpp b/wpilibc/src/test/native/cpp/simulation/SimInitializationTest.cpp index da603b8942..c836d76afa 100644 --- a/wpilibc/src/test/native/cpp/simulation/SimInitializationTest.cpp +++ b/wpilibc/src/test/native/cpp/simulation/SimInitializationTest.cpp @@ -42,6 +42,7 @@ TEST(SimInitializationTests, TestAllInitialize) { PDPSim pdpsim{0}; PWMSim pwmsim{0}; RelaySim rsim{0}; - RoboRioSim rrsim{0}; + RoboRioSim rrsim; + (void)rrsim; SPIAccelerometerSim sasim{0}; } diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/RoboRioSim.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/RoboRioSim.java index 7b78ad5464..7742336998 100644 --- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/RoboRioSim.java +++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/RoboRioSim.java @@ -10,180 +10,192 @@ package edu.wpi.first.wpilibj.simulation; import edu.wpi.first.hal.simulation.NotifyCallback; import edu.wpi.first.hal.simulation.RoboRioDataJNI; -@SuppressWarnings({"PMD.ExcessivePublicCount", "PMD.TooManyMethods"}) +/** + * Class to control a simulated RoboRIO. + */ +@SuppressWarnings({"PMD.ExcessivePublicCount", "PMD.TooManyMethods", "PMD.UseUtilityClass"}) public class RoboRioSim { - private final int m_index; - - public RoboRioSim(int index) { - m_index = index; + public static CallbackStore registerFPGAButtonCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerFPGAButtonCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelFPGAButtonCallback); + } + public static boolean getFPGAButton() { + return RoboRioDataJNI.getFPGAButton(); + } + public static void setFPGAButton(boolean fPGAButton) { + RoboRioDataJNI.setFPGAButton(fPGAButton); } - public CallbackStore registerFPGAButtonCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerFPGAButtonCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelFPGAButtonCallback); + public static CallbackStore registerVInVoltageCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerVInVoltageCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelVInVoltageCallback); } - public boolean getFPGAButton() { - return RoboRioDataJNI.getFPGAButton(m_index); + public static double getVInVoltage() { + return RoboRioDataJNI.getVInVoltage(); } - public void setFPGAButton(boolean fPGAButton) { - RoboRioDataJNI.setFPGAButton(m_index, fPGAButton); + public static void setVInVoltage(double vInVoltage) { + RoboRioDataJNI.setVInVoltage(vInVoltage); } - public CallbackStore registerVInVoltageCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerVInVoltageCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelVInVoltageCallback); + public static CallbackStore registerVInCurrentCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerVInCurrentCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelVInCurrentCallback); } - public double getVInVoltage() { - return RoboRioDataJNI.getVInVoltage(m_index); + public static double getVInCurrent() { + return RoboRioDataJNI.getVInCurrent(); } - public void setVInVoltage(double vInVoltage) { - RoboRioDataJNI.setVInVoltage(m_index, vInVoltage); + public static void setVInCurrent(double vInCurrent) { + RoboRioDataJNI.setVInCurrent(vInCurrent); } - public CallbackStore registerVInCurrentCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerVInCurrentCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelVInCurrentCallback); + public static CallbackStore registerUserVoltage6VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage6VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserVoltage6VCallback); } - public double getVInCurrent() { - return RoboRioDataJNI.getVInCurrent(m_index); + public static double getUserVoltage6V() { + return RoboRioDataJNI.getUserVoltage6V(); } - public void setVInCurrent(double vInCurrent) { - RoboRioDataJNI.setVInCurrent(m_index, vInCurrent); + public static void setUserVoltage6V(double userVoltage6V) { + RoboRioDataJNI.setUserVoltage6V(userVoltage6V); } - public CallbackStore registerUserVoltage6VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserVoltage6VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage6VCallback); + public static CallbackStore registerUserCurrent6VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent6VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserCurrent6VCallback); } - public double getUserVoltage6V() { - return RoboRioDataJNI.getUserVoltage6V(m_index); + public static double getUserCurrent6V() { + return RoboRioDataJNI.getUserCurrent6V(); } - public void setUserVoltage6V(double userVoltage6V) { - RoboRioDataJNI.setUserVoltage6V(m_index, userVoltage6V); + public static void setUserCurrent6V(double userCurrent6V) { + RoboRioDataJNI.setUserCurrent6V(userCurrent6V); } - public CallbackStore registerUserCurrent6VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserCurrent6VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent6VCallback); + public static CallbackStore registerUserActive6VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive6VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserActive6VCallback); } - public double getUserCurrent6V() { - return RoboRioDataJNI.getUserCurrent6V(m_index); + public static boolean getUserActive6V() { + return RoboRioDataJNI.getUserActive6V(); } - public void setUserCurrent6V(double userCurrent6V) { - RoboRioDataJNI.setUserCurrent6V(m_index, userCurrent6V); + public static void setUserActive6V(boolean userActive6V) { + RoboRioDataJNI.setUserActive6V(userActive6V); } - public CallbackStore registerUserActive6VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserActive6VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive6VCallback); + public static CallbackStore registerUserVoltage5VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage5VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserVoltage5VCallback); } - public boolean getUserActive6V() { - return RoboRioDataJNI.getUserActive6V(m_index); + public static double getUserVoltage5V() { + return RoboRioDataJNI.getUserVoltage5V(); } - public void setUserActive6V(boolean userActive6V) { - RoboRioDataJNI.setUserActive6V(m_index, userActive6V); + public static void setUserVoltage5V(double userVoltage5V) { + RoboRioDataJNI.setUserVoltage5V(userVoltage5V); } - public CallbackStore registerUserVoltage5VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserVoltage5VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage5VCallback); + public static CallbackStore registerUserCurrent5VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent5VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserCurrent5VCallback); } - public double getUserVoltage5V() { - return RoboRioDataJNI.getUserVoltage5V(m_index); + public static double getUserCurrent5V() { + return RoboRioDataJNI.getUserCurrent5V(); } - public void setUserVoltage5V(double userVoltage5V) { - RoboRioDataJNI.setUserVoltage5V(m_index, userVoltage5V); + public static void setUserCurrent5V(double userCurrent5V) { + RoboRioDataJNI.setUserCurrent5V(userCurrent5V); } - public CallbackStore registerUserCurrent5VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserCurrent5VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent5VCallback); + public static CallbackStore registerUserActive5VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive5VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserActive5VCallback); } - public double getUserCurrent5V() { - return RoboRioDataJNI.getUserCurrent5V(m_index); + public static boolean getUserActive5V() { + return RoboRioDataJNI.getUserActive5V(); } - public void setUserCurrent5V(double userCurrent5V) { - RoboRioDataJNI.setUserCurrent5V(m_index, userCurrent5V); + public static void setUserActive5V(boolean userActive5V) { + RoboRioDataJNI.setUserActive5V(userActive5V); } - public CallbackStore registerUserActive5VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserActive5VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive5VCallback); + public static CallbackStore registerUserVoltage3V3Callback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserVoltage3V3Callback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserVoltage3V3Callback); } - public boolean getUserActive5V() { - return RoboRioDataJNI.getUserActive5V(m_index); + public static double getUserVoltage3V3() { + return RoboRioDataJNI.getUserVoltage3V3(); } - public void setUserActive5V(boolean userActive5V) { - RoboRioDataJNI.setUserActive5V(m_index, userActive5V); + public static void setUserVoltage3V3(double userVoltage3V3) { + RoboRioDataJNI.setUserVoltage3V3(userVoltage3V3); } - public CallbackStore registerUserVoltage3V3Callback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserVoltage3V3Callback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserVoltage3V3Callback); + public static CallbackStore registerUserCurrent3V3Callback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserCurrent3V3Callback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserCurrent3V3Callback); } - public double getUserVoltage3V3() { - return RoboRioDataJNI.getUserVoltage3V3(m_index); + public static double getUserCurrent3V3() { + return RoboRioDataJNI.getUserCurrent3V3(); } - public void setUserVoltage3V3(double userVoltage3V3) { - RoboRioDataJNI.setUserVoltage3V3(m_index, userVoltage3V3); + public static void setUserCurrent3V3(double userCurrent3V3) { + RoboRioDataJNI.setUserCurrent3V3(userCurrent3V3); } - public CallbackStore registerUserCurrent3V3Callback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserCurrent3V3Callback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserCurrent3V3Callback); + public static CallbackStore registerUserActive3V3Callback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserActive3V3Callback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserActive3V3Callback); } - public double getUserCurrent3V3() { - return RoboRioDataJNI.getUserCurrent3V3(m_index); + public static boolean getUserActive3V3() { + return RoboRioDataJNI.getUserActive3V3(); } - public void setUserCurrent3V3(double userCurrent3V3) { - RoboRioDataJNI.setUserCurrent3V3(m_index, userCurrent3V3); + public static void setUserActive3V3(boolean userActive3V3) { + RoboRioDataJNI.setUserActive3V3(userActive3V3); } - public CallbackStore registerUserActive3V3Callback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserActive3V3Callback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserActive3V3Callback); + public static CallbackStore registerUserFaults6VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults6VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserFaults6VCallback); } - public boolean getUserActive3V3() { - return RoboRioDataJNI.getUserActive3V3(m_index); + public static int getUserFaults6V() { + return RoboRioDataJNI.getUserFaults6V(); } - public void setUserActive3V3(boolean userActive3V3) { - RoboRioDataJNI.setUserActive3V3(m_index, userActive3V3); + public static void setUserFaults6V(int userFaults6V) { + RoboRioDataJNI.setUserFaults6V(userFaults6V); } - public CallbackStore registerUserFaults6VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserFaults6VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults6VCallback); + public static CallbackStore registerUserFaults5VCallback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults5VCallback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserFaults5VCallback); } - public int getUserFaults6V() { - return RoboRioDataJNI.getUserFaults6V(m_index); + public static int getUserFaults5V() { + return RoboRioDataJNI.getUserFaults5V(); } - public void setUserFaults6V(int userFaults6V) { - RoboRioDataJNI.setUserFaults6V(m_index, userFaults6V); + public static void setUserFaults5V(int userFaults5V) { + RoboRioDataJNI.setUserFaults5V(userFaults5V); } - public CallbackStore registerUserFaults5VCallback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserFaults5VCallback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults5VCallback); + public static CallbackStore registerUserFaults3V3Callback(NotifyCallback callback, + boolean initialNotify) { + int uid = RoboRioDataJNI.registerUserFaults3V3Callback(callback, initialNotify); + return new CallbackStore(uid, RoboRioDataJNI::cancelUserFaults3V3Callback); } - public int getUserFaults5V() { - return RoboRioDataJNI.getUserFaults5V(m_index); + public static int getUserFaults3V3() { + return RoboRioDataJNI.getUserFaults3V3(); } - public void setUserFaults5V(int userFaults5V) { - RoboRioDataJNI.setUserFaults5V(m_index, userFaults5V); + public static void setUserFaults3V3(int userFaults3V3) { + RoboRioDataJNI.setUserFaults3V3(userFaults3V3); } - public CallbackStore registerUserFaults3V3Callback(NotifyCallback callback, boolean initialNotify) { - int uid = RoboRioDataJNI.registerUserFaults3V3Callback(m_index, callback, initialNotify); - return new CallbackStore(m_index, uid, RoboRioDataJNI::cancelUserFaults3V3Callback); - } - public int getUserFaults3V3() { - return RoboRioDataJNI.getUserFaults3V3(m_index); - } - public void setUserFaults3V3(int userFaults3V3) { - RoboRioDataJNI.setUserFaults3V3(m_index, userFaults3V3); - } - - public void resetData() { - RoboRioDataJNI.resetData(m_index); + public static void resetData() { + RoboRioDataJNI.resetData(); } }