mirror of
https://github.com/wpilibsuite/allwpilib
synced 2026-06-20 00:51:42 +00:00
Change hal sim to use spinlocks (#1291)
This makes callback registration completely thread safe. This patch also uses templates and macros to dramatically reduce the amount of manual boilerplate.
This commit is contained in:
Peter Johnson
@@ -7,7 +7,6 @@
|
||||
|
||||
#include "../PortsInternal.h"
|
||||
#include "RoboRioDataInternal.h"
|
||||
#include "mockdata/NotifyCallbackHelpers.h"
|
||||
|
||||
using namespace hal;
|
||||
|
||||
@@ -22,576 +21,21 @@ void InitializeRoboRioData() {
|
||||
|
||||
RoboRioData* hal::SimRoboRioData;
|
||||
void RoboRioData::ResetData() {
|
||||
m_fPGAButton = false;
|
||||
m_fPGAButtonCallbacks = nullptr;
|
||||
m_vInVoltage = 0.0;
|
||||
m_vInVoltageCallbacks = nullptr;
|
||||
m_vInCurrent = 0.0;
|
||||
m_vInCurrentCallbacks = nullptr;
|
||||
m_userVoltage6V = 6.0;
|
||||
m_userVoltage6VCallbacks = nullptr;
|
||||
m_userCurrent6V = 0.0;
|
||||
m_userCurrent6VCallbacks = nullptr;
|
||||
m_userActive6V = false;
|
||||
m_userActive6VCallbacks = nullptr;
|
||||
m_userVoltage5V = 5.0;
|
||||
m_userVoltage5VCallbacks = nullptr;
|
||||
m_userCurrent5V = 0.0;
|
||||
m_userCurrent5VCallbacks = nullptr;
|
||||
m_userActive5V = false;
|
||||
m_userActive5VCallbacks = nullptr;
|
||||
m_userVoltage3V3 = 3.3;
|
||||
m_userVoltage3V3Callbacks = nullptr;
|
||||
m_userCurrent3V3 = 0.0;
|
||||
m_userCurrent3V3Callbacks = nullptr;
|
||||
m_userActive3V3 = false;
|
||||
m_userActive3V3Callbacks = nullptr;
|
||||
m_userFaults6V = 0;
|
||||
m_userFaults6VCallbacks = nullptr;
|
||||
m_userFaults5V = 0;
|
||||
m_userFaults5VCallbacks = nullptr;
|
||||
m_userFaults3V3 = 0;
|
||||
m_userFaults3V3Callbacks = nullptr;
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterFPGAButtonCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_fPGAButtonCallbacks = RegisterCallback(
|
||||
m_fPGAButtonCallbacks, "FPGAButton", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeBoolean(GetFPGAButton());
|
||||
callback("FPGAButton", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelFPGAButtonCallback(int32_t uid) {
|
||||
m_fPGAButtonCallbacks = CancelCallback(m_fPGAButtonCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeFPGAButtonCallback(HAL_Value value) {
|
||||
InvokeCallback(m_fPGAButtonCallbacks, "FPGAButton", &value);
|
||||
}
|
||||
|
||||
HAL_Bool RoboRioData::GetFPGAButton() { return m_fPGAButton; }
|
||||
|
||||
void RoboRioData::SetFPGAButton(HAL_Bool fPGAButton) {
|
||||
HAL_Bool oldValue = m_fPGAButton.exchange(fPGAButton);
|
||||
if (oldValue != fPGAButton) {
|
||||
InvokeFPGAButtonCallback(MakeBoolean(fPGAButton));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterVInVoltageCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_vInVoltageCallbacks = RegisterCallback(
|
||||
m_vInVoltageCallbacks, "VInVoltage", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetVInVoltage());
|
||||
callback("VInVoltage", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelVInVoltageCallback(int32_t uid) {
|
||||
m_vInVoltageCallbacks = CancelCallback(m_vInVoltageCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeVInVoltageCallback(HAL_Value value) {
|
||||
InvokeCallback(m_vInVoltageCallbacks, "VInVoltage", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetVInVoltage() { return m_vInVoltage; }
|
||||
|
||||
void RoboRioData::SetVInVoltage(double vInVoltage) {
|
||||
double oldValue = m_vInVoltage.exchange(vInVoltage);
|
||||
if (oldValue != vInVoltage) {
|
||||
InvokeVInVoltageCallback(MakeDouble(vInVoltage));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterVInCurrentCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_vInCurrentCallbacks = RegisterCallback(
|
||||
m_vInCurrentCallbacks, "VInCurrent", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetVInCurrent());
|
||||
callback("VInCurrent", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelVInCurrentCallback(int32_t uid) {
|
||||
m_vInCurrentCallbacks = CancelCallback(m_vInCurrentCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeVInCurrentCallback(HAL_Value value) {
|
||||
InvokeCallback(m_vInCurrentCallbacks, "VInCurrent", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetVInCurrent() { return m_vInCurrent; }
|
||||
|
||||
void RoboRioData::SetVInCurrent(double vInCurrent) {
|
||||
double oldValue = m_vInCurrent.exchange(vInCurrent);
|
||||
if (oldValue != vInCurrent) {
|
||||
InvokeVInCurrentCallback(MakeDouble(vInCurrent));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserVoltage6VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userVoltage6VCallbacks = RegisterCallback(
|
||||
m_userVoltage6VCallbacks, "UserVoltage6V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserVoltage6V());
|
||||
callback("UserVoltage6V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserVoltage6VCallback(int32_t uid) {
|
||||
m_userVoltage6VCallbacks = CancelCallback(m_userVoltage6VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserVoltage6VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userVoltage6VCallbacks, "UserVoltage6V", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserVoltage6V() { return m_userVoltage6V; }
|
||||
|
||||
void RoboRioData::SetUserVoltage6V(double userVoltage6V) {
|
||||
double oldValue = m_userVoltage6V.exchange(userVoltage6V);
|
||||
if (oldValue != userVoltage6V) {
|
||||
InvokeUserVoltage6VCallback(MakeDouble(userVoltage6V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserCurrent6VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userCurrent6VCallbacks = RegisterCallback(
|
||||
m_userCurrent6VCallbacks, "UserCurrent6V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserCurrent6V());
|
||||
callback("UserCurrent6V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserCurrent6VCallback(int32_t uid) {
|
||||
m_userCurrent6VCallbacks = CancelCallback(m_userCurrent6VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserCurrent6VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userCurrent6VCallbacks, "UserCurrent6V", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserCurrent6V() { return m_userCurrent6V; }
|
||||
|
||||
void RoboRioData::SetUserCurrent6V(double userCurrent6V) {
|
||||
double oldValue = m_userCurrent6V.exchange(userCurrent6V);
|
||||
if (oldValue != userCurrent6V) {
|
||||
InvokeUserCurrent6VCallback(MakeDouble(userCurrent6V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserActive6VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userActive6VCallbacks = RegisterCallback(
|
||||
m_userActive6VCallbacks, "UserActive6V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeBoolean(GetUserActive6V());
|
||||
callback("UserActive6V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserActive6VCallback(int32_t uid) {
|
||||
m_userActive6VCallbacks = CancelCallback(m_userActive6VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserActive6VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userActive6VCallbacks, "UserActive6V", &value);
|
||||
}
|
||||
|
||||
HAL_Bool RoboRioData::GetUserActive6V() { return m_userActive6V; }
|
||||
|
||||
void RoboRioData::SetUserActive6V(HAL_Bool userActive6V) {
|
||||
HAL_Bool oldValue = m_userActive6V.exchange(userActive6V);
|
||||
if (oldValue != userActive6V) {
|
||||
InvokeUserActive6VCallback(MakeBoolean(userActive6V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserVoltage5VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userVoltage5VCallbacks = RegisterCallback(
|
||||
m_userVoltage5VCallbacks, "UserVoltage5V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserVoltage5V());
|
||||
callback("UserVoltage5V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserVoltage5VCallback(int32_t uid) {
|
||||
m_userVoltage5VCallbacks = CancelCallback(m_userVoltage5VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserVoltage5VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userVoltage5VCallbacks, "UserVoltage5V", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserVoltage5V() { return m_userVoltage5V; }
|
||||
|
||||
void RoboRioData::SetUserVoltage5V(double userVoltage5V) {
|
||||
double oldValue = m_userVoltage5V.exchange(userVoltage5V);
|
||||
if (oldValue != userVoltage5V) {
|
||||
InvokeUserVoltage5VCallback(MakeDouble(userVoltage5V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserCurrent5VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userCurrent5VCallbacks = RegisterCallback(
|
||||
m_userCurrent5VCallbacks, "UserCurrent5V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserCurrent5V());
|
||||
callback("UserCurrent5V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserCurrent5VCallback(int32_t uid) {
|
||||
m_userCurrent5VCallbacks = CancelCallback(m_userCurrent5VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserCurrent5VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userCurrent5VCallbacks, "UserCurrent5V", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserCurrent5V() { return m_userCurrent5V; }
|
||||
|
||||
void RoboRioData::SetUserCurrent5V(double userCurrent5V) {
|
||||
double oldValue = m_userCurrent5V.exchange(userCurrent5V);
|
||||
if (oldValue != userCurrent5V) {
|
||||
InvokeUserCurrent5VCallback(MakeDouble(userCurrent5V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserActive5VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userActive5VCallbacks = RegisterCallback(
|
||||
m_userActive5VCallbacks, "UserActive5V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeBoolean(GetUserActive5V());
|
||||
callback("UserActive5V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserActive5VCallback(int32_t uid) {
|
||||
m_userActive5VCallbacks = CancelCallback(m_userActive5VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserActive5VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userActive5VCallbacks, "UserActive5V", &value);
|
||||
}
|
||||
|
||||
HAL_Bool RoboRioData::GetUserActive5V() { return m_userActive5V; }
|
||||
|
||||
void RoboRioData::SetUserActive5V(HAL_Bool userActive5V) {
|
||||
HAL_Bool oldValue = m_userActive5V.exchange(userActive5V);
|
||||
if (oldValue != userActive5V) {
|
||||
InvokeUserActive5VCallback(MakeBoolean(userActive5V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserVoltage3V3Callback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userVoltage3V3Callbacks = RegisterCallback(
|
||||
m_userVoltage3V3Callbacks, "UserVoltage3V3", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserVoltage3V3());
|
||||
callback("UserVoltage3V3", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserVoltage3V3Callback(int32_t uid) {
|
||||
m_userVoltage3V3Callbacks = CancelCallback(m_userVoltage3V3Callbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserVoltage3V3Callback(HAL_Value value) {
|
||||
InvokeCallback(m_userVoltage3V3Callbacks, "UserVoltage3V3", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserVoltage3V3() { return m_userVoltage3V3; }
|
||||
|
||||
void RoboRioData::SetUserVoltage3V3(double userVoltage3V3) {
|
||||
double oldValue = m_userVoltage3V3.exchange(userVoltage3V3);
|
||||
if (oldValue != userVoltage3V3) {
|
||||
InvokeUserVoltage3V3Callback(MakeDouble(userVoltage3V3));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserCurrent3V3Callback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userCurrent3V3Callbacks = RegisterCallback(
|
||||
m_userCurrent3V3Callbacks, "UserCurrent3V3", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeDouble(GetUserCurrent3V3());
|
||||
callback("UserCurrent3V3", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserCurrent3V3Callback(int32_t uid) {
|
||||
m_userCurrent3V3Callbacks = CancelCallback(m_userCurrent3V3Callbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserCurrent3V3Callback(HAL_Value value) {
|
||||
InvokeCallback(m_userCurrent3V3Callbacks, "UserCurrent3V3", &value);
|
||||
}
|
||||
|
||||
double RoboRioData::GetUserCurrent3V3() { return m_userCurrent3V3; }
|
||||
|
||||
void RoboRioData::SetUserCurrent3V3(double userCurrent3V3) {
|
||||
double oldValue = m_userCurrent3V3.exchange(userCurrent3V3);
|
||||
if (oldValue != userCurrent3V3) {
|
||||
InvokeUserCurrent3V3Callback(MakeDouble(userCurrent3V3));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserActive3V3Callback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userActive3V3Callbacks = RegisterCallback(
|
||||
m_userActive3V3Callbacks, "UserActive3V3", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeBoolean(GetUserActive3V3());
|
||||
callback("UserActive3V3", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserActive3V3Callback(int32_t uid) {
|
||||
m_userActive3V3Callbacks = CancelCallback(m_userActive3V3Callbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserActive3V3Callback(HAL_Value value) {
|
||||
InvokeCallback(m_userActive3V3Callbacks, "UserActive3V3", &value);
|
||||
}
|
||||
|
||||
HAL_Bool RoboRioData::GetUserActive3V3() { return m_userActive3V3; }
|
||||
|
||||
void RoboRioData::SetUserActive3V3(HAL_Bool userActive3V3) {
|
||||
HAL_Bool oldValue = m_userActive3V3.exchange(userActive3V3);
|
||||
if (oldValue != userActive3V3) {
|
||||
InvokeUserActive3V3Callback(MakeBoolean(userActive3V3));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserFaults6VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userFaults6VCallbacks = RegisterCallback(
|
||||
m_userFaults6VCallbacks, "UserFaults6V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeInt(GetUserFaults6V());
|
||||
callback("UserFaults6V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserFaults6VCallback(int32_t uid) {
|
||||
m_userFaults6VCallbacks = CancelCallback(m_userFaults6VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserFaults6VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userFaults6VCallbacks, "UserFaults6V", &value);
|
||||
}
|
||||
|
||||
int32_t RoboRioData::GetUserFaults6V() { return m_userFaults6V; }
|
||||
|
||||
void RoboRioData::SetUserFaults6V(int32_t userFaults6V) {
|
||||
int32_t oldValue = m_userFaults6V.exchange(userFaults6V);
|
||||
if (oldValue != userFaults6V) {
|
||||
InvokeUserFaults6VCallback(MakeInt(userFaults6V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserFaults5VCallback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userFaults5VCallbacks = RegisterCallback(
|
||||
m_userFaults5VCallbacks, "UserFaults5V", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeInt(GetUserFaults5V());
|
||||
callback("UserFaults5V", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserFaults5VCallback(int32_t uid) {
|
||||
m_userFaults5VCallbacks = CancelCallback(m_userFaults5VCallbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserFaults5VCallback(HAL_Value value) {
|
||||
InvokeCallback(m_userFaults5VCallbacks, "UserFaults5V", &value);
|
||||
}
|
||||
|
||||
int32_t RoboRioData::GetUserFaults5V() { return m_userFaults5V; }
|
||||
|
||||
void RoboRioData::SetUserFaults5V(int32_t userFaults5V) {
|
||||
int32_t oldValue = m_userFaults5V.exchange(userFaults5V);
|
||||
if (oldValue != userFaults5V) {
|
||||
InvokeUserFaults5VCallback(MakeInt(userFaults5V));
|
||||
}
|
||||
}
|
||||
|
||||
int32_t RoboRioData::RegisterUserFaults3V3Callback(HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
// Must return -1 on a null callback for error handling
|
||||
if (callback == nullptr) return -1;
|
||||
int32_t newUid = 0;
|
||||
{
|
||||
std::lock_guard<wpi::mutex> lock(m_registerMutex);
|
||||
m_userFaults3V3Callbacks = RegisterCallback(
|
||||
m_userFaults3V3Callbacks, "UserFaults3V3", callback, param, &newUid);
|
||||
}
|
||||
if (initialNotify) {
|
||||
// We know that the callback is not null because of earlier null check
|
||||
HAL_Value value = MakeInt(GetUserFaults3V3());
|
||||
callback("UserFaults3V3", param, &value);
|
||||
}
|
||||
return newUid;
|
||||
}
|
||||
|
||||
void RoboRioData::CancelUserFaults3V3Callback(int32_t uid) {
|
||||
m_userFaults3V3Callbacks = CancelCallback(m_userFaults3V3Callbacks, uid);
|
||||
}
|
||||
|
||||
void RoboRioData::InvokeUserFaults3V3Callback(HAL_Value value) {
|
||||
InvokeCallback(m_userFaults3V3Callbacks, "UserFaults3V3", &value);
|
||||
}
|
||||
|
||||
int32_t RoboRioData::GetUserFaults3V3() { return m_userFaults3V3; }
|
||||
|
||||
void RoboRioData::SetUserFaults3V3(int32_t userFaults3V3) {
|
||||
int32_t oldValue = m_userFaults3V3.exchange(userFaults3V3);
|
||||
if (oldValue != userFaults3V3) {
|
||||
InvokeUserFaults3V3Callback(MakeInt(userFaults3V3));
|
||||
}
|
||||
fpgaButton.Reset(false);
|
||||
vInVoltage.Reset(0.0);
|
||||
vInCurrent.Reset(0.0);
|
||||
userVoltage6V.Reset(6.0);
|
||||
userCurrent6V.Reset(0.0);
|
||||
userActive6V.Reset(false);
|
||||
userVoltage5V.Reset(5.0);
|
||||
userCurrent5V.Reset(0.0);
|
||||
userActive5V.Reset(false);
|
||||
userVoltage3V3.Reset(3.3);
|
||||
userCurrent3V3.Reset(0.0);
|
||||
userActive3V3.Reset(false);
|
||||
userFaults6V.Reset(0);
|
||||
userFaults5V.Reset(0);
|
||||
userFaults3V3.Reset(0);
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
@@ -599,336 +43,46 @@ void HALSIM_ResetRoboRioData(int32_t index) {
|
||||
SimRoboRioData[index].ResetData();
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioFPGAButtonCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterFPGAButtonCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
#define DEFINE_CAPI(TYPE, CAPINAME, LOWERNAME) \
|
||||
HAL_SIMDATAVALUE_DEFINE_CAPI(TYPE, HALSIM, RoboRio##CAPINAME, \
|
||||
SimRoboRioData, LOWERNAME)
|
||||
|
||||
void HALSIM_CancelRoboRioFPGAButtonCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelFPGAButtonCallback(uid);
|
||||
}
|
||||
DEFINE_CAPI(HAL_Bool, FPGAButton, fpgaButton)
|
||||
DEFINE_CAPI(double, VInVoltage, vInVoltage)
|
||||
DEFINE_CAPI(double, VInCurrent, vInCurrent)
|
||||
DEFINE_CAPI(double, UserVoltage6V, userVoltage6V)
|
||||
DEFINE_CAPI(double, UserCurrent6V, userCurrent6V)
|
||||
DEFINE_CAPI(HAL_Bool, UserActive6V, userActive6V)
|
||||
DEFINE_CAPI(double, UserVoltage5V, userVoltage5V)
|
||||
DEFINE_CAPI(double, UserCurrent5V, userCurrent5V)
|
||||
DEFINE_CAPI(HAL_Bool, UserActive5V, userActive5V)
|
||||
DEFINE_CAPI(double, UserVoltage3V3, userVoltage3V3)
|
||||
DEFINE_CAPI(double, UserCurrent3V3, userCurrent3V3)
|
||||
DEFINE_CAPI(HAL_Bool, UserActive3V3, userActive3V3)
|
||||
DEFINE_CAPI(int32_t, UserFaults6V, userFaults6V)
|
||||
DEFINE_CAPI(int32_t, UserFaults5V, userFaults5V)
|
||||
DEFINE_CAPI(int32_t, UserFaults3V3, userFaults3V3)
|
||||
|
||||
HAL_Bool HALSIM_GetRoboRioFPGAButton(int32_t index) {
|
||||
return SimRoboRioData[index].GetFPGAButton();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioFPGAButton(int32_t index, HAL_Bool fPGAButton) {
|
||||
SimRoboRioData[index].SetFPGAButton(fPGAButton);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioVInVoltageCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterVInVoltageCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioVInVoltageCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelVInVoltageCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioVInVoltage(int32_t index) {
|
||||
return SimRoboRioData[index].GetVInVoltage();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioVInVoltage(int32_t index, double vInVoltage) {
|
||||
SimRoboRioData[index].SetVInVoltage(vInVoltage);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioVInCurrentCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterVInCurrentCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioVInCurrentCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelVInCurrentCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioVInCurrent(int32_t index) {
|
||||
return SimRoboRioData[index].GetVInCurrent();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioVInCurrent(int32_t index, double vInCurrent) {
|
||||
SimRoboRioData[index].SetVInCurrent(vInCurrent);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserVoltage6VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserVoltage6VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserVoltage6VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserVoltage6VCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserVoltage6V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserVoltage6V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserVoltage6V(int32_t index, double userVoltage6V) {
|
||||
SimRoboRioData[index].SetUserVoltage6V(userVoltage6V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserCurrent6VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserCurrent6VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserCurrent6VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserCurrent6VCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserCurrent6V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserCurrent6V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserCurrent6V(int32_t index, double userCurrent6V) {
|
||||
SimRoboRioData[index].SetUserCurrent6V(userCurrent6V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserActive6VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserActive6VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserActive6VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserActive6VCallback(uid);
|
||||
}
|
||||
|
||||
HAL_Bool HALSIM_GetRoboRioUserActive6V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserActive6V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserActive6V(int32_t index, HAL_Bool userActive6V) {
|
||||
SimRoboRioData[index].SetUserActive6V(userActive6V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserVoltage5VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserVoltage5VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserVoltage5VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserVoltage5VCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserVoltage5V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserVoltage5V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserVoltage5V(int32_t index, double userVoltage5V) {
|
||||
SimRoboRioData[index].SetUserVoltage5V(userVoltage5V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserCurrent5VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserCurrent5VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserCurrent5VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserCurrent5VCallback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserCurrent5V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserCurrent5V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserCurrent5V(int32_t index, double userCurrent5V) {
|
||||
SimRoboRioData[index].SetUserCurrent5V(userCurrent5V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserActive5VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserActive5VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserActive5VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserActive5VCallback(uid);
|
||||
}
|
||||
|
||||
HAL_Bool HALSIM_GetRoboRioUserActive5V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserActive5V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserActive5V(int32_t index, HAL_Bool userActive5V) {
|
||||
SimRoboRioData[index].SetUserActive5V(userActive5V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserVoltage3V3Callback(
|
||||
int32_t index, HAL_NotifyCallback callback, void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserVoltage3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserVoltage3V3Callback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserVoltage3V3Callback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserVoltage3V3(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserVoltage3V3();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserVoltage3V3(int32_t index, double userVoltage3V3) {
|
||||
SimRoboRioData[index].SetUserVoltage3V3(userVoltage3V3);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserCurrent3V3Callback(
|
||||
int32_t index, HAL_NotifyCallback callback, void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserCurrent3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserCurrent3V3Callback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserCurrent3V3Callback(uid);
|
||||
}
|
||||
|
||||
double HALSIM_GetRoboRioUserCurrent3V3(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserCurrent3V3();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserCurrent3V3(int32_t index, double userCurrent3V3) {
|
||||
SimRoboRioData[index].SetUserCurrent3V3(userCurrent3V3);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserActive3V3Callback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserActive3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserActive3V3Callback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserActive3V3Callback(uid);
|
||||
}
|
||||
|
||||
HAL_Bool HALSIM_GetRoboRioUserActive3V3(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserActive3V3();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserActive3V3(int32_t index, HAL_Bool userActive3V3) {
|
||||
SimRoboRioData[index].SetUserActive3V3(userActive3V3);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserFaults6VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserFaults6VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserFaults6VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserFaults6VCallback(uid);
|
||||
}
|
||||
|
||||
int32_t HALSIM_GetRoboRioUserFaults6V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserFaults6V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserFaults6V(int32_t index, int32_t userFaults6V) {
|
||||
SimRoboRioData[index].SetUserFaults6V(userFaults6V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserFaults5VCallback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserFaults5VCallback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserFaults5VCallback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserFaults5VCallback(uid);
|
||||
}
|
||||
|
||||
int32_t HALSIM_GetRoboRioUserFaults5V(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserFaults5V();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserFaults5V(int32_t index, int32_t userFaults5V) {
|
||||
SimRoboRioData[index].SetUserFaults5V(userFaults5V);
|
||||
}
|
||||
|
||||
int32_t HALSIM_RegisterRoboRioUserFaults3V3Callback(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param,
|
||||
HAL_Bool initialNotify) {
|
||||
return SimRoboRioData[index].RegisterUserFaults3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
}
|
||||
|
||||
void HALSIM_CancelRoboRioUserFaults3V3Callback(int32_t index, int32_t uid) {
|
||||
SimRoboRioData[index].CancelUserFaults3V3Callback(uid);
|
||||
}
|
||||
|
||||
int32_t HALSIM_GetRoboRioUserFaults3V3(int32_t index) {
|
||||
return SimRoboRioData[index].GetUserFaults3V3();
|
||||
}
|
||||
|
||||
void HALSIM_SetRoboRioUserFaults3V3(int32_t index, int32_t userFaults3V3) {
|
||||
SimRoboRioData[index].SetUserFaults3V3(userFaults3V3);
|
||||
}
|
||||
#define REGISTER(NAME) \
|
||||
SimRoboRioData[index].NAME.RegisterCallback(callback, param, initialNotify)
|
||||
|
||||
void HALSIM_RegisterRoboRioAllCallbacks(int32_t index,
|
||||
HAL_NotifyCallback callback,
|
||||
void* param, HAL_Bool initialNotify) {
|
||||
SimRoboRioData[index].RegisterFPGAButtonCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterVInVoltageCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterVInCurrentCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserVoltage6VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserCurrent6VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserActive6VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserVoltage5VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserCurrent5VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserActive5VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserVoltage3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserCurrent3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserActive3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserFaults6VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserFaults5VCallback(callback, param,
|
||||
initialNotify);
|
||||
SimRoboRioData[index].RegisterUserFaults3V3Callback(callback, param,
|
||||
initialNotify);
|
||||
REGISTER(fpgaButton);
|
||||
REGISTER(vInVoltage);
|
||||
REGISTER(vInCurrent);
|
||||
REGISTER(userVoltage6V);
|
||||
REGISTER(userCurrent6V);
|
||||
REGISTER(userActive6V);
|
||||
REGISTER(userVoltage5V);
|
||||
REGISTER(userCurrent5V);
|
||||
REGISTER(userActive5V);
|
||||
REGISTER(userVoltage3V3);
|
||||
REGISTER(userCurrent3V3);
|
||||
REGISTER(userActive3V3);
|
||||
REGISTER(userFaults6V);
|
||||
REGISTER(userFaults5V);
|
||||
REGISTER(userFaults3V3);
|
||||
}
|
||||
} // extern "C"
|
||||
|
||||
Reference in New Issue
Block a user