diff --git a/hal/src/main/java/edu/wpi/first/hal/PowerDistributionFaults.java b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionFaults.java new file mode 100644 index 0000000000..bdff5993c9 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionFaults.java @@ -0,0 +1,123 @@ +// Copyright (c) FIRST and other WPILib contributors. +// Open Source Software; you can modify and/or share it under the terms of +// the WPILib BSD license file in the root directory of this project. + +package edu.wpi.first.hal; + +public class PowerDistributionFaults { + @SuppressWarnings("MemberName") + public final boolean Channel0BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel1BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel2BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel3BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel4BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel5BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel6BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel7BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel8BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel9BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel10BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel11BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel12BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel13BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel14BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel15BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel16BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel17BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel18BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel19BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel20BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel21BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel22BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel23BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Brownout; + + @SuppressWarnings("MemberName") + public final boolean CanWarning; + + @SuppressWarnings("MemberName") + public final boolean HardwareFault; + + /** + * Constructs from a bitfield. + * + * @param faults faults + */ + public PowerDistributionFaults(int faults) { + Channel0BreakerFault = (faults & 0x1) != 0; + Channel1BreakerFault = (faults & 0x2) != 0; + Channel2BreakerFault = (faults & 0x4) != 0; + Channel3BreakerFault = (faults & 0x8) != 0; + Channel4BreakerFault = (faults & 0x10) != 0; + Channel5BreakerFault = (faults & 0x20) != 0; + Channel6BreakerFault = (faults & 0x40) != 0; + Channel7BreakerFault = (faults & 0x80) != 0; + Channel8BreakerFault = (faults & 0x100) != 0; + Channel9BreakerFault = (faults & 0x200) != 0; + Channel10BreakerFault = (faults & 0x400) != 0; + Channel11BreakerFault = (faults & 0x800) != 0; + Channel12BreakerFault = (faults & 0x1000) != 0; + Channel13BreakerFault = (faults & 0x2000) != 0; + Channel14BreakerFault = (faults & 0x4000) != 0; + Channel15BreakerFault = (faults & 0x8000) != 0; + Channel16BreakerFault = (faults & 0x10000) != 0; + Channel17BreakerFault = (faults & 0x20000) != 0; + Channel18BreakerFault = (faults & 0x40000) != 0; + Channel19BreakerFault = (faults & 0x80000) != 0; + Channel20BreakerFault = (faults & 0x100000) != 0; + Channel21BreakerFault = (faults & 0x200000) != 0; + Channel22BreakerFault = (faults & 0x400000) != 0; + Channel23BreakerFault = (faults & 0x800000) != 0; + Brownout = (faults & 0x1000000) != 0; + CanWarning = (faults & 0x2000000) != 0; + HardwareFault = (faults & 0x4000000) != 0; + } +} diff --git a/hal/src/main/java/edu/wpi/first/hal/PowerDistributionJNI.java b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionJNI.java index 877dde3d1b..00c4dd1d80 100644 --- a/hal/src/main/java/edu/wpi/first/hal/PowerDistributionJNI.java +++ b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionJNI.java @@ -56,4 +56,18 @@ public class PowerDistributionJNI extends JNIWrapper { public static native boolean getSwitchableChannelNoError(int handle); public static native void setSwitchableChannelNoError(int handle, boolean enabled); + + public static native int getFaultsNative(int handle); + + public static PowerDistributionFaults getFaults(int handle) { + return new PowerDistributionFaults(getFaultsNative(handle)); + } + + public static native int getStickyFaultsNative(int handle); + + public static PowerDistributionStickyFaults getStickyFaults(int handle) { + return new PowerDistributionStickyFaults(getStickyFaultsNative(handle)); + } + + public static native PowerDistributionVersion getVersion(int handle); } diff --git a/hal/src/main/java/edu/wpi/first/hal/PowerDistributionStickyFaults.java b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionStickyFaults.java new file mode 100644 index 0000000000..0eb4a69084 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionStickyFaults.java @@ -0,0 +1,127 @@ +// Copyright (c) FIRST and other WPILib contributors. +// Open Source Software; you can modify and/or share it under the terms of +// the WPILib BSD license file in the root directory of this project. + +package edu.wpi.first.hal; + +public class PowerDistributionStickyFaults { + @SuppressWarnings("MemberName") + public final boolean Channel0BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel1BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel2BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel3BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel4BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel5BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel6BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel7BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel8BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel9BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel10BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel11BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel12BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel13BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel14BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel15BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel16BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel17BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel18BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel19BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel20BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel21BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel22BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Channel23BreakerFault; + + @SuppressWarnings("MemberName") + public final boolean Brownout; + + @SuppressWarnings("MemberName") + public final boolean CanWarning; + + @SuppressWarnings("MemberName") + public final boolean CanBusOff; + + @SuppressWarnings("MemberName") + public final boolean HasReset; + + /** + * Constructs from a bitfield. + * + * @param faults faults + */ + public PowerDistributionStickyFaults(int faults) { + Channel0BreakerFault = (faults & 0x1) != 0; + Channel1BreakerFault = (faults & 0x2) != 0; + Channel2BreakerFault = (faults & 0x4) != 0; + Channel3BreakerFault = (faults & 0x8) != 0; + Channel4BreakerFault = (faults & 0x10) != 0; + Channel5BreakerFault = (faults & 0x20) != 0; + Channel6BreakerFault = (faults & 0x40) != 0; + Channel7BreakerFault = (faults & 0x80) != 0; + Channel8BreakerFault = (faults & 0x100) != 0; + Channel9BreakerFault = (faults & 0x200) != 0; + Channel10BreakerFault = (faults & 0x400) != 0; + Channel11BreakerFault = (faults & 0x800) != 0; + Channel12BreakerFault = (faults & 0x1000) != 0; + Channel13BreakerFault = (faults & 0x2000) != 0; + Channel14BreakerFault = (faults & 0x4000) != 0; + Channel15BreakerFault = (faults & 0x8000) != 0; + Channel16BreakerFault = (faults & 0x10000) != 0; + Channel17BreakerFault = (faults & 0x20000) != 0; + Channel18BreakerFault = (faults & 0x40000) != 0; + Channel19BreakerFault = (faults & 0x80000) != 0; + Channel20BreakerFault = (faults & 0x100000) != 0; + Channel21BreakerFault = (faults & 0x200000) != 0; + Channel22BreakerFault = (faults & 0x400000) != 0; + Channel23BreakerFault = (faults & 0x800000) != 0; + Brownout = (faults & 0x1000000) != 0; + CanWarning = (faults & 0x2000000) != 0; + CanBusOff = (faults & 0x4000000) != 0; + HasReset = (faults & 0x8000000) != 0; + } +} diff --git a/hal/src/main/java/edu/wpi/first/hal/PowerDistributionVersion.java b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionVersion.java new file mode 100644 index 0000000000..0c733a2303 --- /dev/null +++ b/hal/src/main/java/edu/wpi/first/hal/PowerDistributionVersion.java @@ -0,0 +1,50 @@ +// Copyright (c) FIRST and other WPILib contributors. +// Open Source Software; you can modify and/or share it under the terms of +// the WPILib BSD license file in the root directory of this project. + +package edu.wpi.first.hal; + +public class PowerDistributionVersion { + @SuppressWarnings("MemberName") + public final int firmwareMajor; + + @SuppressWarnings("MemberName") + public final int firmwareMinor; + + @SuppressWarnings("MemberName") + public final int firmwareFix; + + @SuppressWarnings("MemberName") + public final int hardwareMinor; + + @SuppressWarnings("MemberName") + public final int hardwareMajor; + + @SuppressWarnings("MemberName") + public final int uniqueId; + + /** + * Constructs a power distribution version (Called from the HAL). + * + * @param firmwareMajor firmware major + * @param firmwareMinor firmware minor + * @param firmwareFix firmware fix + * @param hardwareMinor hardware minor + * @param hardwareMajor hardware major + * @param uniqueId unique id + */ + public PowerDistributionVersion( + int firmwareMajor, + int firmwareMinor, + int firmwareFix, + int hardwareMinor, + int hardwareMajor, + int uniqueId) { + this.firmwareMajor = firmwareMajor; + this.firmwareMinor = firmwareMinor; + this.firmwareFix = firmwareFix; + this.hardwareMinor = hardwareMinor; + this.hardwareMajor = hardwareMajor; + this.uniqueId = uniqueId; + } +} diff --git a/hal/src/main/native/athena/PowerDistribution.cpp b/hal/src/main/native/athena/PowerDistribution.cpp index ff21ec0e74..0d2b963432 100644 --- a/hal/src/main/native/athena/PowerDistribution.cpp +++ b/hal/src/main/native/athena/PowerDistribution.cpp @@ -4,6 +4,7 @@ #include "hal/PowerDistribution.h" +#include #include #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" diff --git a/hal/src/main/native/athena/REVPDH.cpp b/hal/src/main/native/athena/REVPDH.cpp index f9f1e4f2eb..1359c98ae4 100644 --- a/hal/src/main/native/athena/REVPDH.cpp +++ b/hal/src/main/native/athena/REVPDH.cpp @@ -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) { diff --git a/hal/src/main/native/athena/REVPDH.h b/hal/src/main/native/athena/REVPDH.h index 113256cd91..d0b10f2777 100644 --- a/hal/src/main/native/athena/REVPDH.h +++ b/hal/src/main/native/athena/REVPDH.h @@ -6,6 +6,7 @@ #include +#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. diff --git a/hal/src/main/native/cpp/jni/HALUtil.cpp b/hal/src/main/native/cpp/jni/HALUtil.cpp index 5fff4f5b18..5d5a9588b4 100644 --- a/hal/src/main/native/cpp/jni/HALUtil.cpp +++ b/hal/src/main/native/cpp/jni/HALUtil.cpp @@ -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, "", "(IIIIII)V"); + return env->NewObject( + powerDistributionVersionCls, constructor, + static_cast(firmwareMajor), static_cast(firmwareMinor), + static_cast(firmwareFix), static_cast(hardwareMinor), + static_cast(hardwareMajor), static_cast(uniqueId)); +} + JavaVM* GetJVM() { return jvm; } diff --git a/hal/src/main/native/cpp/jni/HALUtil.h b/hal/src/main/native/cpp/jni/HALUtil.h index bbbffd0397..cf3956c7f3 100644 --- a/hal/src/main/native/cpp/jni/HALUtil.h +++ b/hal/src/main/native/cpp/jni/HALUtil.h @@ -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 diff --git a/hal/src/main/native/cpp/jni/PowerDistributionJNI.cpp b/hal/src/main/native/cpp/jni/PowerDistributionJNI.cpp index cac0739865..9d85ea4a9c 100644 --- a/hal/src/main/native/cpp/jni/PowerDistributionJNI.cpp +++ b/hal/src/main/native/cpp/jni/PowerDistributionJNI.cpp @@ -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" diff --git a/hal/src/main/native/include/hal/PowerDistribution.h b/hal/src/main/native/include/hal/PowerDistribution.h index fabb8b7389..47cc9b2c34 100644 --- a/hal/src/main/native/include/hal/PowerDistribution.h +++ b/hal/src/main/native/include/hal/PowerDistribution.h @@ -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 diff --git a/hal/src/main/native/sim/PowerDistribution.cpp b/hal/src/main/native/sim/PowerDistribution.cpp index 47073750b7..ddda420b77 100644 --- a/hal/src/main/native/sim/PowerDistribution.cpp +++ b/hal/src/main/native/sim/PowerDistribution.cpp @@ -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" diff --git a/wpilibc/src/main/native/cpp/PowerDistribution.cpp b/wpilibc/src/main/native/cpp/PowerDistribution.cpp index 383a65f20b..a74821d5b5 100644 --- a/wpilibc/src/main/native/cpp/PowerDistribution.cpp +++ b/wpilibc/src/main/native/cpp/PowerDistribution.cpp @@ -137,6 +137,48 @@ void PowerDistribution::SetSwitchableChannel(bool enabled) { FRC_ReportError(status, "Module {}", m_module); } +PowerDistribution::Version PowerDistribution::GetVersion() const { + int32_t status = 0; + HAL_PowerDistributionVersion halVersion; + std::memset(&halVersion, 0, sizeof(halVersion)); + HAL_GetPowerDistributionVersion(m_handle, &halVersion, &status); + FRC_ReportError(status, "Module {}", m_module); + PowerDistribution::Version version; + static_assert(sizeof(halVersion) == sizeof(version)); + static_assert(std::is_standard_layout_v); + static_assert(std::is_trivial_v); + std::memcpy(&version, &halVersion, sizeof(version)); + return version; +} + +PowerDistribution::Faults PowerDistribution::GetFaults() const { + int32_t status = 0; + HAL_PowerDistributionFaults halFaults; + std::memset(&halFaults, 0, sizeof(halFaults)); + HAL_GetPowerDistributionFaults(m_handle, &halFaults, &status); + FRC_ReportError(status, "Module {}", m_module); + PowerDistribution::Faults faults; + static_assert(sizeof(halFaults) == sizeof(faults)); + static_assert(std::is_standard_layout_v); + static_assert(std::is_trivial_v); + std::memcpy(&faults, &halFaults, sizeof(faults)); + return faults; +} + +PowerDistribution::StickyFaults PowerDistribution::GetStickyFaults() const { + int32_t status = 0; + HAL_PowerDistributionStickyFaults halStickyFaults; + std::memset(&halStickyFaults, 0, sizeof(halStickyFaults)); + HAL_GetPowerDistributionStickyFaults(m_handle, &halStickyFaults, &status); + FRC_ReportError(status, "Module {}", m_module); + PowerDistribution::StickyFaults stickyFaults; + static_assert(sizeof(halStickyFaults) == sizeof(stickyFaults)); + static_assert(std::is_standard_layout_v); + static_assert(std::is_trivial_v); + std::memcpy(&stickyFaults, &halStickyFaults, sizeof(stickyFaults)); + return stickyFaults; +} + void PowerDistribution::InitSendable(wpi::SendableBuilder& builder) { builder.SetSmartDashboardType("PowerDistribution"); int32_t status = 0; diff --git a/wpilibc/src/main/native/include/frc/PowerDistribution.h b/wpilibc/src/main/native/include/frc/PowerDistribution.h index 85e2156dc8..356f83ce2a 100644 --- a/wpilibc/src/main/native/include/frc/PowerDistribution.h +++ b/wpilibc/src/main/native/include/frc/PowerDistribution.h @@ -102,6 +102,82 @@ class PowerDistribution : public wpi::Sendable, void SetSwitchableChannel(bool enabled); + struct Version { + uint32_t FirmwareMajor; + uint32_t FirmwareMinor; + uint32_t FirmwareFix; + uint32_t FardwareMinor; + uint32_t FardwareMajor; + uint32_t UniqueId; + }; + + Version GetVersion() const; + + struct Faults { + 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; + }; + + Faults GetFaults() const; + + struct StickyFaults { + 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; + }; + + StickyFaults GetStickyFaults() const; + void InitSendable(wpi::SendableBuilder& builder) override; private: diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/PowerDistribution.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/PowerDistribution.java index dd37d44a7d..12057a43e2 100644 --- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/PowerDistribution.java +++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/PowerDistribution.java @@ -6,7 +6,10 @@ package edu.wpi.first.wpilibj; import edu.wpi.first.hal.FRCNetComm.tResourceType; import edu.wpi.first.hal.HAL; +import edu.wpi.first.hal.PowerDistributionFaults; import edu.wpi.first.hal.PowerDistributionJNI; +import edu.wpi.first.hal.PowerDistributionStickyFaults; +import edu.wpi.first.hal.PowerDistributionVersion; import edu.wpi.first.util.sendable.Sendable; import edu.wpi.first.util.sendable.SendableBuilder; import edu.wpi.first.util.sendable.SendableRegistry; @@ -157,6 +160,18 @@ public class PowerDistribution implements Sendable, AutoCloseable { PowerDistributionJNI.setSwitchableChannel(m_handle, enabled); } + PowerDistributionVersion getVersion() { + return PowerDistributionJNI.getVersion(m_handle); + } + + PowerDistributionFaults getFaults() { + return PowerDistributionJNI.getFaults(m_handle); + } + + PowerDistributionStickyFaults getStickyFaults() { + return PowerDistributionJNI.getStickyFaults(m_handle); + } + @Override public void initSendable(SendableBuilder builder) { builder.setSmartDashboardType("PowerDistribution");