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

[wpilib, hal] High Level REV PH changes (#3792)

Browse Source 
More functionality was implemented at the HAL level, so expose that to the wpilib level.

This also does units changes for all the PH related functionality.
This commit is contained in:
Thad House
2021-12-19 13:41:35 -08:00
committed by GitHub
parent 59a7528fd6
commit 34b2d0dae1
23 changed files with 770 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
wpilibc/src/main/native/cpp/PneumaticHub.cpp
View File

@@ -52,6 +52,7 @@ class PneumaticHub::DataStore {
bool m_compressorReserved{false};
wpi::mutex m_reservedLock;
PneumaticHub m_moduleObject{HAL_kInvalidHandle, 0};
std::array<units::second_t, 16> m_oneShotDurMs{0_s};
};
PneumaticHub::PneumaticHub()
@@ -76,69 +77,69 @@ PneumaticHub::PneumaticHub(HAL_REVPHHandle handle, int module)
bool PneumaticHub::GetCompressor() const {
int32_t status = 0;
auto result = HAL_GetREVPHCompressor(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
return result;
}
void PneumaticHub::DisableCompressor() {
int32_t status = 0;
HAL_SetREVPHClosedLoopControlDisabled(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
}
void PneumaticHub::EnableCompressorDigital() {
int32_t status = 0;
HAL_SetREVPHClosedLoopControlDigital(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
}
void PneumaticHub::EnableCompressorAnalog(double minAnalogVoltage,
double maxAnalogVoltage) {
void PneumaticHub::EnableCompressorAnalog(units::volt_t minAnalogVoltage,
units::volt_t maxAnalogVoltage) {
int32_t status = 0;
HAL_SetREVPHClosedLoopControlAnalog(m_handle, minAnalogVoltage,
maxAnalogVoltage, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
HAL_SetREVPHClosedLoopControlAnalog(m_handle, minAnalogVoltage.value(),
maxAnalogVoltage.value(), &status);
FRC_ReportError(status, "Module {}", m_module);
}
void PneumaticHub::EnableCompressorHybrid(double minAnalogVoltage,
double maxAnalogVoltage) {
void PneumaticHub::EnableCompressorHybrid(units::volt_t minAnalogVoltage,
units::volt_t maxAnalogVoltage) {
int32_t status = 0;
HAL_SetREVPHClosedLoopControlHybrid(m_handle, minAnalogVoltage,
maxAnalogVoltage, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
HAL_SetREVPHClosedLoopControlHybrid(m_handle, minAnalogVoltage.value(),
maxAnalogVoltage.value(), &status);
FRC_ReportError(status, "Module {}", m_module);
}
CompressorConfigType PneumaticHub::GetCompressorConfigType() const {
int32_t status = 0;
auto result = HAL_GetREVPHCompressorConfig(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
return static_cast<CompressorConfigType>(result);
}
bool PneumaticHub::GetPressureSwitch() const {
int32_t status = 0;
auto result = HAL_GetREVPHPressureSwitch(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
return result;
}
double PneumaticHub::GetCompressorCurrent() const {
units::ampere_t PneumaticHub::GetCompressorCurrent() const {
int32_t status = 0;
auto result = HAL_GetREVPHCompressorCurrent(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
return result;
FRC_ReportError(status, "Module {}", m_module);
return units::ampere_t{result};
}
void PneumaticHub::SetSolenoids(int mask, int values) {
int32_t status = 0;
HAL_SetREVPHSolenoids(m_handle, mask, values, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
}
int PneumaticHub::GetSolenoids() const {
int32_t status = 0;
auto result = HAL_GetREVPHSolenoids(m_handle, &status);
FRC_CheckErrorStatus(status, "Module {}", m_module);
FRC_ReportError(status, "Module {}", m_module);
return result;
}
@@ -147,27 +148,26 @@ int PneumaticHub::GetModuleNumber() const {
}
int PneumaticHub::GetSolenoidDisabledList() const {
return 0;
// TODO Fix me
// int32_t status = 0;
// auto result = HAL_GetREVPHSolenoidDisabledList(m_handle, &status);
// FRC_CheckErrorStatus(status, "Module {}", m_module);
// return result;
int32_t status = 0;
HAL_REVPHStickyFaults faults;
std::memset(&faults, 0, sizeof(faults));
HAL_GetREVPHStickyFaults(m_handle, &faults, &status);
FRC_ReportError(status, "Module {}", m_module);
uint32_t intFaults = 0;
static_assert(sizeof(faults) == sizeof(intFaults));
std::memcpy(&intFaults, &faults, sizeof(faults));
return intFaults & 0xFFFF;
}
void PneumaticHub::FireOneShot(int index) {
// TODO Fix me
// int32_t status = 0;
// HAL_FireREVPHOneShot(m_handle, index, &status);
// FRC_CheckErrorStatus(status, "Module {}", m_module);
int32_t status = 0;
HAL_FireREVPHOneShot(m_handle, index,
m_dataStore->m_oneShotDurMs[index].value(), &status);
FRC_ReportError(status, "Module {}", m_module);
}
void PneumaticHub::SetOneShotDuration(int index, units::second_t duration) {
// TODO Fix me
// int32_t status = 0;
// units::millisecond_t millis = duration;
// HAL_SetREVPHOneShotDuration(m_handle, index, millis.to<int32_t>(),
// &status); FRC_CheckErrorStatus(status, "Module {}", m_module);
m_dataStore->m_oneShotDurMs[index] = duration;
}
bool PneumaticHub::CheckSolenoidChannel(int channel) const {
@@ -203,6 +203,89 @@ void PneumaticHub::UnreserveCompressor() {
m_dataStore->m_compressorReserved = false;
}
PneumaticHub::Version PneumaticHub::GetVersion() const {
int32_t status = 0;
HAL_REVPHVersion halVersions;
std::memset(&halVersions, 0, sizeof(halVersions));
HAL_GetREVPHVersion(m_handle, &halVersions, &status);
FRC_ReportError(status, "Module {}", m_module);
PneumaticHub::Version versions;
static_assert(sizeof(halVersions) == sizeof(versions));
static_assert(std::is_standard_layout_v<decltype(versions)>);
static_assert(std::is_trivial_v<decltype(versions)>);
std::memcpy(&versions, &halVersions, sizeof(versions));
return versions;
}
PneumaticHub::Faults PneumaticHub::GetFaults() const {
int32_t status = 0;
HAL_REVPHFaults halFaults;
std::memset(&halFaults, 0, sizeof(halFaults));
HAL_GetREVPHFaults(m_handle, &halFaults, &status);
FRC_ReportError(status, "Module {}", m_module);
PneumaticHub::Faults faults;
static_assert(sizeof(halFaults) == sizeof(faults));
static_assert(std::is_standard_layout_v<decltype(faults)>);
static_assert(std::is_trivial_v<decltype(faults)>);
std::memcpy(&faults, &halFaults, sizeof(faults));
return faults;
}
PneumaticHub::StickyFaults PneumaticHub::GetStickyFaults() const {
int32_t status = 0;
HAL_REVPHStickyFaults halStickyFaults;
std::memset(&halStickyFaults, 0, sizeof(halStickyFaults));
HAL_GetREVPHStickyFaults(m_handle, &halStickyFaults, &status);
FRC_ReportError(status, "Module {}", m_module);
PneumaticHub::StickyFaults stickyFaults;
static_assert(sizeof(halStickyFaults) == sizeof(stickyFaults));
static_assert(std::is_standard_layout_v<decltype(stickyFaults)>);
static_assert(std::is_trivial_v<decltype(stickyFaults)>);
std::memcpy(&stickyFaults, &halStickyFaults, sizeof(stickyFaults));
return stickyFaults;
}
void PneumaticHub::ClearStickyFaults() {
int32_t status = 0;
HAL_ClearREVPHStickyFaults(m_handle, &status);
FRC_ReportError(status, "Module {}", m_module);
}
units::volt_t PneumaticHub::GetInputVoltage() const {
int32_t status = 0;
auto voltage = HAL_GetREVPHVoltage(m_handle, &status);
FRC_ReportError(status, "Module {}", m_module);
return units::volt_t{voltage};
}
units::volt_t PneumaticHub::Get5VRegulatedVoltage() const {
int32_t status = 0;
auto voltage = HAL_GetREVPH5VVoltage(m_handle, &status);
FRC_ReportError(status, "Module {}", m_module);
return units::volt_t{voltage};
}
units::ampere_t PneumaticHub::GetSolenoidsTotalCurrent() const {
int32_t status = 0;
auto current = HAL_GetREVPHSolenoidCurrent(m_handle, &status);
FRC_ReportError(status, "Module {}", m_module);
return units::ampere_t{current};
}
units::volt_t PneumaticHub::GetSolenoidsVoltage() const {
int32_t status = 0;
auto voltage = HAL_GetREVPHSolenoidVoltage(m_handle, &status);
FRC_ReportError(status, "Module {}", m_module);
return units::volt_t{voltage};
}
units::volt_t PneumaticHub::GetAnalogVoltage(int channel) const {
int32_t status = 0;
auto voltage = HAL_GetREVPHAnalogVoltage(m_handle, channel, &status);
FRC_ReportError(status, "Module {}", m_module);
return units::volt_t{voltage};
}
Solenoid PneumaticHub::MakeSolenoid(int channel) {
return Solenoid{m_module, PneumaticsModuleType::REVPH, channel};
}