Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-29 02:21:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

[wpilib, hal] Add support for getting faults and versions from power distribution (#3794)

Browse Source
This commit is contained in:
Thad House
2021-12-19 13:42:49 -08:00
committed by GitHub
parent 34b2d0dae1
commit 9778626f34
15 changed files with 743 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
hal/src/main/native/athena/PowerDistribution.cpp
View File

@@ -4,6 +4,7 @@
#include "hal/PowerDistribution.h"
#include <cstring>
#include <thread>
#include "CTREPDP.h"
@@ -242,4 +243,34 @@ HAL_Bool HAL_GetPowerDistributionSwitchableChannel(
}
}
void HAL_GetPowerDistributionVersion(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionVersion* version,
int32_t* status) {
if (IsCtre(handle)) {
std::memset(version, 0, sizeof(*version));
} else {
HAL_GetREVPDHVersion(handle, version, status);
}
}
void HAL_GetPowerDistributionFaults(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionFaults* faults,
int32_t* status) {
if (IsCtre(handle)) {
std::memset(faults, 0, sizeof(*faults));
} else {
HAL_GetREVPDHFaults(handle, faults, status);
}
}
void HAL_GetPowerDistributionStickyFaults(
HAL_PowerDistributionHandle handle,
HAL_PowerDistributionStickyFaults* stickyFaults, int32_t* status) {
if (IsCtre(handle)) {
std::memset(stickyFaults, 0, sizeof(*stickyFaults));
} else {
HAL_GetREVPDHStickyFaults(handle, stickyFaults, status);
}
}
} // extern "C"

158
hal/src/main/native/athena/REVPDH.cpp
View File

@@ -476,10 +476,10 @@ double HAL_GetREVPDHVoltage(HAL_REVPDHHandle handle, int32_t* status) {
return PDH_status_4_v_bus_decode(statusFrame.v_bus);
}
HAL_REVPDHVersion HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
int32_t* status) {
HAL_REVPDHVersion version;
std::memset(&version, 0, sizeof(version));
void HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
HAL_PowerDistributionVersion* version,
int32_t* status) {
std::memset(version, 0, sizeof(*version));
uint8_t packedData[8] = {0};
int32_t length = 0;
uint64_t timestamp = 0;
@@ -487,14 +487,14 @@ HAL_REVPDHVersion HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
auto hpdh = REVPDHHandles->Get(handle);
if (hpdh == nullptr) {
*status = HAL_HANDLE_ERROR;
return version;
return;
}
HAL_WriteCANRTRFrame(hpdh->hcan, PDH_VERSION_LENGTH, PDH_VERSION_FRAME_API,
status);
if (*status != 0) {
return version;
return;
}
HAL_ReadCANPacketTimeout(hpdh->hcan, PDH_VERSION_FRAME_API, packedData,
@@ -502,27 +502,26 @@ HAL_REVPDHVersion HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
status);
if (*status != 0) {
return version;
return;
}
PDH_version_unpack(&result, packedData, PDH_VERSION_LENGTH);
version.firmwareMajor = result.firmware_year;
version.firmwareMinor = result.firmware_minor;
version.firmwareFix = result.firmware_fix;
version.hardwareMinor = result.hardware_minor;
version.hardwareMajor = result.hardware_major;
version.uniqueId = result.unique_id;
return version;
version->firmwareMajor = result.firmware_year;
version->firmwareMinor = result.firmware_minor;
version->firmwareFix = result.firmware_fix;
version->hardwareMinor = result.hardware_minor;
version->hardwareMajor = result.hardware_major;
version->uniqueId = result.unique_id;
}
HAL_REVPDHFaults HAL_GetREVPDHFaults(HAL_REVPDHHandle handle, int32_t* status) {
HAL_REVPDHFaults faults = {};
void HAL_GetREVPDHFaults(HAL_REVPDHHandle handle,
HAL_PowerDistributionFaults* faults, int32_t* status) {
std::memset(faults, 0, sizeof(*faults));
auto hpdh = REVPDHHandles->Get(handle);
if (hpdh == nullptr) {
*status = HAL_HANDLE_ERROR;
return faults;
return;
}
PDH_status_0_t status0 = HAL_ReadREVPDHStatus0(hpdh->hcan, status);
@@ -531,78 +530,75 @@ HAL_REVPDHFaults HAL_GetREVPDHFaults(HAL_REVPDHHandle handle, int32_t* status) {
PDH_status_3_t status3 = HAL_ReadREVPDHStatus3(hpdh->hcan, status);
PDH_status_4_t status4 = HAL_ReadREVPDHStatus4(hpdh->hcan, status);
faults.channel0BreakerFault = status0.channel_0_breaker_fault;
faults.channel1BreakerFault = status0.channel_1_breaker_fault;
faults.channel2BreakerFault = status0.channel_2_breaker_fault;
faults.channel3BreakerFault = status0.channel_3_breaker_fault;
faults.channel4BreakerFault = status1.channel_4_breaker_fault;
faults.channel5BreakerFault = status1.channel_5_breaker_fault;
faults.channel6BreakerFault = status1.channel_6_breaker_fault;
faults.channel7BreakerFault = status1.channel_7_breaker_fault;
faults.channel8BreakerFault = status2.channel_8_breaker_fault;
faults.channel9BreakerFault = status2.channel_9_breaker_fault;
faults.channel10BreakerFault = status2.channel_10_breaker_fault;
faults.channel11BreakerFault = status2.channel_11_breaker_fault;
faults.channel12BreakerFault = status3.channel_12_breaker_fault;
faults.channel13BreakerFault = status3.channel_13_breaker_fault;
faults.channel14BreakerFault = status3.channel_14_breaker_fault;
faults.channel15BreakerFault = status3.channel_15_breaker_fault;
faults.channel16BreakerFault = status3.channel_16_breaker_fault;
faults.channel17BreakerFault = status3.channel_17_breaker_fault;
faults.channel18BreakerFault = status3.channel_18_breaker_fault;
faults.channel19BreakerFault = status3.channel_19_breaker_fault;
faults.channel20BreakerFault = status3.channel_20_breaker_fault;
faults.channel21BreakerFault = status3.channel_21_breaker_fault;
faults.channel22BreakerFault = status3.channel_22_breaker_fault;
faults.channel23BreakerFault = status3.channel_23_breaker_fault;
faults.brownout = status4.brownout_fault;
faults.canWarning = status4.can_warning_fault;
faults.hardwareFault = status4.hardware_fault;
return faults;
faults->channel0BreakerFault = status0.channel_0_breaker_fault;
faults->channel1BreakerFault = status0.channel_1_breaker_fault;
faults->channel2BreakerFault = status0.channel_2_breaker_fault;
faults->channel3BreakerFault = status0.channel_3_breaker_fault;
faults->channel4BreakerFault = status1.channel_4_breaker_fault;
faults->channel5BreakerFault = status1.channel_5_breaker_fault;
faults->channel6BreakerFault = status1.channel_6_breaker_fault;
faults->channel7BreakerFault = status1.channel_7_breaker_fault;
faults->channel8BreakerFault = status2.channel_8_breaker_fault;
faults->channel9BreakerFault = status2.channel_9_breaker_fault;
faults->channel10BreakerFault = status2.channel_10_breaker_fault;
faults->channel11BreakerFault = status2.channel_11_breaker_fault;
faults->channel12BreakerFault = status3.channel_12_breaker_fault;
faults->channel13BreakerFault = status3.channel_13_breaker_fault;
faults->channel14BreakerFault = status3.channel_14_breaker_fault;
faults->channel15BreakerFault = status3.channel_15_breaker_fault;
faults->channel16BreakerFault = status3.channel_16_breaker_fault;
faults->channel17BreakerFault = status3.channel_17_breaker_fault;
faults->channel18BreakerFault = status3.channel_18_breaker_fault;
faults->channel19BreakerFault = status3.channel_19_breaker_fault;
faults->channel20BreakerFault = status3.channel_20_breaker_fault;
faults->channel21BreakerFault = status3.channel_21_breaker_fault;
faults->channel22BreakerFault = status3.channel_22_breaker_fault;
faults->channel23BreakerFault = status3.channel_23_breaker_fault;
faults->brownout = status4.brownout_fault;
faults->canWarning = status4.can_warning_fault;
faults->hardwareFault = status4.hardware_fault;
}
HAL_REVPDHStickyFaults HAL_GetREVPDHStickyFaults(HAL_REVPDHHandle handle,
int32_t* status) {
HAL_REVPDHStickyFaults stickyFaults = {};
void HAL_GetREVPDHStickyFaults(HAL_REVPDHHandle handle,
HAL_PowerDistributionStickyFaults* stickyFaults,
int32_t* status) {
std::memset(stickyFaults, 0, sizeof(*stickyFaults));
auto hpdh = REVPDHHandles->Get(handle);
if (hpdh == nullptr) {
*status = HAL_HANDLE_ERROR;
return stickyFaults;
return;
}
PDH_status_4_t status4 = HAL_ReadREVPDHStatus4(hpdh->hcan, status);
stickyFaults.channel0BreakerFault = status4.sticky_ch0_breaker_fault;
stickyFaults.channel1BreakerFault = status4.sticky_ch1_breaker_fault;
stickyFaults.channel2BreakerFault = status4.sticky_ch2_breaker_fault;
stickyFaults.channel3BreakerFault = status4.sticky_ch3_breaker_fault;
stickyFaults.channel4BreakerFault = status4.sticky_ch4_breaker_fault;
stickyFaults.channel5BreakerFault = status4.sticky_ch5_breaker_fault;
stickyFaults.channel6BreakerFault = status4.sticky_ch6_breaker_fault;
stickyFaults.channel7BreakerFault = status4.sticky_ch7_breaker_fault;
stickyFaults.channel8BreakerFault = status4.sticky_ch8_breaker_fault;
stickyFaults.channel9BreakerFault = status4.sticky_ch9_breaker_fault;
stickyFaults.channel10BreakerFault = status4.sticky_ch10_breaker_fault;
stickyFaults.channel11BreakerFault = status4.sticky_ch11_breaker_fault;
stickyFaults.channel12BreakerFault = status4.sticky_ch12_breaker_fault;
stickyFaults.channel13BreakerFault = status4.sticky_ch13_breaker_fault;
stickyFaults.channel14BreakerFault = status4.sticky_ch14_breaker_fault;
stickyFaults.channel15BreakerFault = status4.sticky_ch15_breaker_fault;
stickyFaults.channel16BreakerFault = status4.sticky_ch16_breaker_fault;
stickyFaults.channel17BreakerFault = status4.sticky_ch17_breaker_fault;
stickyFaults.channel18BreakerFault = status4.sticky_ch18_breaker_fault;
stickyFaults.channel19BreakerFault = status4.sticky_ch19_breaker_fault;
stickyFaults.channel20BreakerFault = status4.sticky_ch20_breaker_fault;
stickyFaults.channel21BreakerFault = status4.sticky_ch21_breaker_fault;
stickyFaults.channel22BreakerFault = status4.sticky_ch22_breaker_fault;
stickyFaults.channel23BreakerFault = status4.sticky_ch23_breaker_fault;
stickyFaults.brownout = status4.sticky_brownout_fault;
stickyFaults.canWarning = status4.sticky_can_warning_fault;
stickyFaults.canBusOff = status4.sticky_can_bus_off_fault;
stickyFaults.hasReset = status4.sticky_has_reset_fault;
return stickyFaults;
stickyFaults->channel0BreakerFault = status4.sticky_ch0_breaker_fault;
stickyFaults->channel1BreakerFault = status4.sticky_ch1_breaker_fault;
stickyFaults->channel2BreakerFault = status4.sticky_ch2_breaker_fault;
stickyFaults->channel3BreakerFault = status4.sticky_ch3_breaker_fault;
stickyFaults->channel4BreakerFault = status4.sticky_ch4_breaker_fault;
stickyFaults->channel5BreakerFault = status4.sticky_ch5_breaker_fault;
stickyFaults->channel6BreakerFault = status4.sticky_ch6_breaker_fault;
stickyFaults->channel7BreakerFault = status4.sticky_ch7_breaker_fault;
stickyFaults->channel8BreakerFault = status4.sticky_ch8_breaker_fault;
stickyFaults->channel9BreakerFault = status4.sticky_ch9_breaker_fault;
stickyFaults->channel10BreakerFault = status4.sticky_ch10_breaker_fault;
stickyFaults->channel11BreakerFault = status4.sticky_ch11_breaker_fault;
stickyFaults->channel12BreakerFault = status4.sticky_ch12_breaker_fault;
stickyFaults->channel13BreakerFault = status4.sticky_ch13_breaker_fault;
stickyFaults->channel14BreakerFault = status4.sticky_ch14_breaker_fault;
stickyFaults->channel15BreakerFault = status4.sticky_ch15_breaker_fault;
stickyFaults->channel16BreakerFault = status4.sticky_ch16_breaker_fault;
stickyFaults->channel17BreakerFault = status4.sticky_ch17_breaker_fault;
stickyFaults->channel18BreakerFault = status4.sticky_ch18_breaker_fault;
stickyFaults->channel19BreakerFault = status4.sticky_ch19_breaker_fault;
stickyFaults->channel20BreakerFault = status4.sticky_ch20_breaker_fault;
stickyFaults->channel21BreakerFault = status4.sticky_ch21_breaker_fault;
stickyFaults->channel22BreakerFault = status4.sticky_ch22_breaker_fault;
stickyFaults->channel23BreakerFault = status4.sticky_ch23_breaker_fault;
stickyFaults->brownout = status4.sticky_brownout_fault;
stickyFaults->canWarning = status4.sticky_can_warning_fault;
stickyFaults->canBusOff = status4.sticky_can_bus_off_fault;
stickyFaults->hasReset = status4.sticky_has_reset_fault;
}
void HAL_ClearREVPDHStickyFaults(HAL_REVPDHHandle handle, int32_t* status) {

93
hal/src/main/native/athena/REVPDH.h
View File

@@ -6,6 +6,7 @@
#include <stdint.h>
#include "hal/PowerDistribution.h"
#include "hal/Types.h"
/**
@@ -14,85 +15,6 @@
* @{
*/
/**
* Storage for REV PDH Version
*/
struct HAL_REVPDHVersion {
uint32_t firmwareMajor;
uint32_t firmwareMinor;
uint32_t firmwareFix;
uint32_t hardwareMinor;
uint32_t hardwareMajor;
uint32_t uniqueId;
};
/**
* Storage for REV PDH Faults
*/
struct HAL_REVPDHFaults {
uint32_t channel0BreakerFault : 1;
uint32_t channel1BreakerFault : 1;
uint32_t channel2BreakerFault : 1;
uint32_t channel3BreakerFault : 1;
uint32_t channel4BreakerFault : 1;
uint32_t channel5BreakerFault : 1;
uint32_t channel6BreakerFault : 1;
uint32_t channel7BreakerFault : 1;
uint32_t channel8BreakerFault : 1;
uint32_t channel9BreakerFault : 1;
uint32_t channel10BreakerFault : 1;
uint32_t channel11BreakerFault : 1;
uint32_t channel12BreakerFault : 1;
uint32_t channel13BreakerFault : 1;
uint32_t channel14BreakerFault : 1;
uint32_t channel15BreakerFault : 1;
uint32_t channel16BreakerFault : 1;
uint32_t channel17BreakerFault : 1;
uint32_t channel18BreakerFault : 1;
uint32_t channel19BreakerFault : 1;
uint32_t channel20BreakerFault : 1;
uint32_t channel21BreakerFault : 1;
uint32_t channel22BreakerFault : 1;
uint32_t channel23BreakerFault : 1;
uint32_t brownout : 1;
uint32_t canWarning : 1;
uint32_t hardwareFault : 1;
};
/**
* Storage for REV PDH Sticky Faults
*/
struct HAL_REVPDHStickyFaults {
uint32_t channel0BreakerFault : 1;
uint32_t channel1BreakerFault : 1;
uint32_t channel2BreakerFault : 1;
uint32_t channel3BreakerFault : 1;
uint32_t channel4BreakerFault : 1;
uint32_t channel5BreakerFault : 1;
uint32_t channel6BreakerFault : 1;
uint32_t channel7BreakerFault : 1;
uint32_t channel8BreakerFault : 1;
uint32_t channel9BreakerFault : 1;
uint32_t channel10BreakerFault : 1;
uint32_t channel11BreakerFault : 1;
uint32_t channel12BreakerFault : 1;
uint32_t channel13BreakerFault : 1;
uint32_t channel14BreakerFault : 1;
uint32_t channel15BreakerFault : 1;
uint32_t channel16BreakerFault : 1;
uint32_t channel17BreakerFault : 1;
uint32_t channel18BreakerFault : 1;
uint32_t channel19BreakerFault : 1;
uint32_t channel20BreakerFault : 1;
uint32_t channel21BreakerFault : 1;
uint32_t channel22BreakerFault : 1;
uint32_t channel23BreakerFault : 1;
uint32_t brownout : 1;
uint32_t canWarning : 1;
uint32_t canBusOff : 1;
uint32_t hasReset : 1;
};
#ifdef __cplusplus
extern "C" {
#endif
@@ -195,8 +117,9 @@ HAL_Bool HAL_GetREVPDHSwitchableChannelState(HAL_REVPDHHandle handle,
*
* @return version information
*/
HAL_REVPDHVersion HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
int32_t* status);
void HAL_GetREVPDHVersion(HAL_REVPDHHandle handle,
HAL_PowerDistributionVersion* version,
int32_t* status);
/**
* Gets the voltage being supplied to a PDH device.
@@ -214,7 +137,8 @@ double HAL_GetREVPDHVoltage(HAL_REVPDHHandle handle, int32_t* status);
*
* @return the faults of the PDH
*/
HAL_REVPDHFaults HAL_GetREVPDHFaults(HAL_REVPDHHandle handle, int32_t* status);
void HAL_GetREVPDHFaults(HAL_REVPDHHandle handle,
HAL_PowerDistributionFaults* faults, int32_t* status);
/**
* Gets the sticky faults of a PDH device.
@@ -223,8 +147,9 @@ HAL_REVPDHFaults HAL_GetREVPDHFaults(HAL_REVPDHHandle handle, int32_t* status);
*
* @return the sticky faults of the PDH
*/
HAL_REVPDHStickyFaults HAL_GetREVPDHStickyFaults(HAL_REVPDHHandle handle,
int32_t* status);
void HAL_GetREVPDHStickyFaults(HAL_REVPDHHandle handle,
HAL_PowerDistributionStickyFaults* stickyFaults,
int32_t* status);
/**
* Clears the sticky faults on a PDH device.

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

@@ -46,6 +46,7 @@ static JException canMessageNotFoundExCls;
static JException canMessageNotAllowedExCls;
static JException canNotInitializedExCls;
static JException uncleanStatusExCls;
static JClass powerDistributionVersionCls;
static JClass pwmConfigDataResultCls;
static JClass canStatusCls;
static JClass matchInfoDataCls;
@@ -56,6 +57,8 @@ static JClass baseStoreCls;
static JClass revPHVersionCls;
static const JClassInit classes[] = {
{"edu/wpi/first/hal/PowerDistributionVersion",
&powerDistributionVersionCls},
{"edu/wpi/first/hal/PWMConfigDataResult", &pwmConfigDataResultCls},
{"edu/wpi/first/hal/can/CANStatus", &canStatusCls},
{"edu/wpi/first/hal/MatchInfoData", &matchInfoDataCls},
@@ -333,6 +336,21 @@ jobject CreateDMABaseStore(JNIEnv* env, jint valueType, jint index) {
return env->NewObject(baseStoreCls, ctor, valueType, index);
}
jobject CreatePowerDistributionVersion(JNIEnv* env, uint32_t firmwareMajor,
uint32_t firmwareMinor,
uint32_t firmwareFix,
uint32_t hardwareMinor,
uint32_t hardwareMajor,
uint32_t uniqueId) {
static jmethodID constructor =
env->GetMethodID(powerDistributionVersionCls, "<init>", "(IIIIII)V");
return env->NewObject(
powerDistributionVersionCls, constructor,
static_cast<jint>(firmwareMajor), static_cast<jint>(firmwareMinor),
static_cast<jint>(firmwareFix), static_cast<jint>(hardwareMinor),
static_cast<jint>(hardwareMajor), static_cast<jint>(uniqueId));
}
JavaVM* GetJVM() {
return jvm;
}

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

@@ -82,6 +82,13 @@ jobject CreateHALValue(JNIEnv* env, const HAL_Value& value);
jobject CreateDMABaseStore(JNIEnv* env, jint valueType, jint index);
jobject CreatePowerDistributionVersion(JNIEnv* env, uint32_t firmwareMajor,
uint32_t firmwareMinor,
uint32_t firmwareFix,
uint32_t hardwareMinor,
uint32_t hardwareMajor,
uint32_t uniqueId);
JavaVM* GetJVM();
} // namespace hal

59
hal/src/main/native/cpp/jni/PowerDistributionJNI.cpp
View File

@@ -362,4 +362,63 @@ Java_edu_wpi_first_hal_PowerDistributionJNI_getSwitchableChannelNoError
return state;
}
/*
* Class: edu_wpi_first_hal_PowerDistributionJNI
* Method: getStickyFaultsNative
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_PowerDistributionJNI_getStickyFaultsNative
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_PowerDistributionStickyFaults halFaults;
std::memset(&halFaults, 0, sizeof(halFaults));
HAL_GetPowerDistributionStickyFaults(handle, &halFaults, &status);
CheckStatus(env, status, false);
jint faults;
static_assert(sizeof(faults) == sizeof(halFaults));
std::memcpy(&faults, &halFaults, sizeof(faults));
return faults;
}
/*
* Class: edu_wpi_first_hal_PowerDistributionJNI
* Method: getFaultsNative
* Signature: (I)I
*/
JNIEXPORT jint JNICALL
Java_edu_wpi_first_hal_PowerDistributionJNI_getFaultsNative
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_PowerDistributionFaults halFaults;
std::memset(&halFaults, 0, sizeof(halFaults));
HAL_GetPowerDistributionFaults(handle, &halFaults, &status);
CheckStatus(env, status, false);
jint faults;
static_assert(sizeof(faults) == sizeof(halFaults));
std::memcpy(&faults, &halFaults, sizeof(faults));
return faults;
}
/*
* Class: edu_wpi_first_hal_PowerDistributionJNI
* Method: getVersion
* Signature: (I)Ljava/lang/Object;
*/
JNIEXPORT jobject JNICALL
Java_edu_wpi_first_hal_PowerDistributionJNI_getVersion
(JNIEnv* env, jclass, jint handle)
{
int32_t status = 0;
HAL_PowerDistributionVersion version;
std::memset(&version, 0, sizeof(version));
HAL_GetPowerDistributionVersion(handle, &version, &status);
CheckStatus(env, status, false);
return CreatePowerDistributionVersion(
env, version.firmwareMajor, version.firmwareMinor, version.firmwareFix,
version.hardwareMinor, version.hardwareMajor, version.uniqueId);
}
} // extern "C"

83
hal/src/main/native/include/hal/PowerDistribution.h
View File

@@ -218,6 +218,89 @@ void HAL_SetPowerDistributionSwitchableChannel(
HAL_Bool HAL_GetPowerDistributionSwitchableChannel(
HAL_PowerDistributionHandle handle, int32_t* status);
struct HAL_PowerDistributionVersion {
uint32_t firmwareMajor;
uint32_t firmwareMinor;
uint32_t firmwareFix;
uint32_t hardwareMinor;
uint32_t hardwareMajor;
uint32_t uniqueId;
};
struct HAL_PowerDistributionFaults {
uint32_t channel0BreakerFault : 1;
uint32_t channel1BreakerFault : 1;
uint32_t channel2BreakerFault : 1;
uint32_t channel3BreakerFault : 1;
uint32_t channel4BreakerFault : 1;
uint32_t channel5BreakerFault : 1;
uint32_t channel6BreakerFault : 1;
uint32_t channel7BreakerFault : 1;
uint32_t channel8BreakerFault : 1;
uint32_t channel9BreakerFault : 1;
uint32_t channel10BreakerFault : 1;
uint32_t channel11BreakerFault : 1;
uint32_t channel12BreakerFault : 1;
uint32_t channel13BreakerFault : 1;
uint32_t channel14BreakerFault : 1;
uint32_t channel15BreakerFault : 1;
uint32_t channel16BreakerFault : 1;
uint32_t channel17BreakerFault : 1;
uint32_t channel18BreakerFault : 1;
uint32_t channel19BreakerFault : 1;
uint32_t channel20BreakerFault : 1;
uint32_t channel21BreakerFault : 1;
uint32_t channel22BreakerFault : 1;
uint32_t channel23BreakerFault : 1;
uint32_t brownout : 1;
uint32_t canWarning : 1;
uint32_t hardwareFault : 1;
};
/**
* Storage for REV PDH Sticky Faults
*/
struct HAL_PowerDistributionStickyFaults {
uint32_t channel0BreakerFault : 1;
uint32_t channel1BreakerFault : 1;
uint32_t channel2BreakerFault : 1;
uint32_t channel3BreakerFault : 1;
uint32_t channel4BreakerFault : 1;
uint32_t channel5BreakerFault : 1;
uint32_t channel6BreakerFault : 1;
uint32_t channel7BreakerFault : 1;
uint32_t channel8BreakerFault : 1;
uint32_t channel9BreakerFault : 1;
uint32_t channel10BreakerFault : 1;
uint32_t channel11BreakerFault : 1;
uint32_t channel12BreakerFault : 1;
uint32_t channel13BreakerFault : 1;
uint32_t channel14BreakerFault : 1;
uint32_t channel15BreakerFault : 1;
uint32_t channel16BreakerFault : 1;
uint32_t channel17BreakerFault : 1;
uint32_t channel18BreakerFault : 1;
uint32_t channel19BreakerFault : 1;
uint32_t channel20BreakerFault : 1;
uint32_t channel21BreakerFault : 1;
uint32_t channel22BreakerFault : 1;
uint32_t channel23BreakerFault : 1;
uint32_t brownout : 1;
uint32_t canWarning : 1;
uint32_t canBusOff : 1;
uint32_t hasReset : 1;
};
void HAL_GetPowerDistributionVersion(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionVersion* version,
int32_t* status);
void HAL_GetPowerDistributionFaults(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionFaults* faults,
int32_t* status);
void HAL_GetPowerDistributionStickyFaults(
HAL_PowerDistributionHandle handle,
HAL_PowerDistributionStickyFaults* stickyFaults, int32_t* status);
#ifdef __cplusplus
} // extern "C"
#endif

12
hal/src/main/native/sim/PowerDistribution.cpp
View File

@@ -168,4 +168,16 @@ HAL_Bool HAL_GetPowerDistributionSwitchableChannel(
HAL_PowerDistributionHandle handle, int32_t* status) {
return false;
}
void HAL_GetPowerDistributionVersion(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionVersion* version,
int32_t* status) {}
void HAL_GetPowerDistributionFaults(HAL_PowerDistributionHandle handle,
HAL_PowerDistributionFaults* faults,
int32_t* status) {}
void HAL_GetPowerDistributionStickyFaults(
HAL_PowerDistributionHandle handle,
HAL_PowerDistributionStickyFaults* stickyFaults, int32_t* status) {}
} // extern "C"