Moves the HAL priority_ custom types to the hal namespace (#532)

There is a shim for backwards compatibility, just like the frc namespace. As with the frc namespace, the library compiles without the shim.
2026-07-04 03:11:43 +00:00 · 2017-05-11 21:25:22 -07:00
parent 16e71eac43
commit efec0c5cc3
47 changed files with 250 additions and 223 deletions
--- a/wpilibc/athena/src/DigitalGlitchFilter.cpp
+++ b/wpilibc/athena/src/DigitalGlitchFilter.cpp
@@ -22,10 +22,10 @@ using namespace frc;

 std::array<bool, 3> DigitalGlitchFilter::m_filterAllocated = {
    {false, false, false}};
-priority_mutex DigitalGlitchFilter::m_mutex;
+hal::priority_mutex DigitalGlitchFilter::m_mutex;

 DigitalGlitchFilter::DigitalGlitchFilter() {
-  std::lock_guard<priority_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_mutex> sync(m_mutex);
  auto index =
      std::find(m_filterAllocated.begin(), m_filterAllocated.end(), false);
  wpi_assert(index != m_filterAllocated.end());
@@ -38,7 +38,7 @@ DigitalGlitchFilter::DigitalGlitchFilter() {

 DigitalGlitchFilter::~DigitalGlitchFilter() {
  if (m_channelIndex >= 0) {
-    std::lock_guard<priority_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_mutex> sync(m_mutex);
    m_filterAllocated[m_channelIndex] = false;
  }
 }
--- a/wpilibc/athena/src/DriverStation.cpp
+++ b/wpilibc/athena/src/DriverStation.cpp
@@ -90,7 +90,7 @@ double DriverStation::GetStickAxis(int stick, int axis) {
    wpi_setWPIError(BadJoystickIndex);
    return 0;
  }
-  std::unique_lock<priority_mutex> lock(m_joystickDataMutex);
+  std::unique_lock<hal::priority_mutex> lock(m_joystickDataMutex);
  if (axis >= m_joystickAxes[stick].count) {
    // Unlock early so error printing isn't locked.
    m_joystickDataMutex.unlock();
@@ -116,7 +116,7 @@ int DriverStation::GetStickPOV(int stick, int pov) {
    wpi_setWPIError(BadJoystickIndex);
    return -1;
  }
-  std::unique_lock<priority_mutex> lock(m_joystickDataMutex);
+  std::unique_lock<hal::priority_mutex> lock(m_joystickDataMutex);
  if (pov >= m_joystickPOVs[stick].count) {
    // Unlock early so error printing isn't locked.
    lock.unlock();
@@ -142,7 +142,7 @@ int DriverStation::GetStickButtons(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return 0;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return m_joystickButtons[stick].buttons;
 }

@@ -163,7 +163,7 @@ bool DriverStation::GetStickButton(int stick, int button) {
        "ERROR: Button indexes begin at 1 in WPILib for C++ and Java");
    return false;
  }
-  std::unique_lock<priority_mutex> lock(m_joystickDataMutex);
+  std::unique_lock<hal::priority_mutex> lock(m_joystickDataMutex);
  if (button > m_joystickButtons[stick].count) {
    // Unlock early so error printing isn't locked.
    lock.unlock();
@@ -187,7 +187,7 @@ int DriverStation::GetStickAxisCount(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return 0;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return m_joystickAxes[stick].count;
 }

@@ -202,7 +202,7 @@ int DriverStation::GetStickPOVCount(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return 0;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return m_joystickPOVs[stick].count;
 }

@@ -217,7 +217,7 @@ int DriverStation::GetStickButtonCount(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return 0;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return m_joystickButtons[stick].count;
 }

@@ -232,7 +232,7 @@ bool DriverStation::GetJoystickIsXbox(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return false;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return static_cast<bool>(m_joystickDescriptor[stick].isXbox);
 }

@@ -247,7 +247,7 @@ int DriverStation::GetJoystickType(int stick) const {
    wpi_setWPIError(BadJoystickIndex);
    return -1;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return static_cast<int>(m_joystickDescriptor[stick].type);
 }

@@ -261,7 +261,7 @@ std::string DriverStation::GetJoystickName(int stick) const {
  if (stick >= kJoystickPorts) {
    wpi_setWPIError(BadJoystickIndex);
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  std::string retVal(m_joystickDescriptor[stick].name);
  return retVal;
 }
@@ -277,7 +277,7 @@ int DriverStation::GetJoystickAxisType(int stick, int axis) const {
    wpi_setWPIError(BadJoystickIndex);
    return -1;
  }
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  return m_joystickDescriptor[stick].axisTypes[axis];
 }

@@ -528,7 +528,7 @@ void DriverStation::GetData() {
  UpdateControlWord(true, controlWord);
  // Obtain a write lock on the data, swap the cached data into the
  // main data arrays
-  std::lock_guard<priority_mutex> lock(m_joystickDataMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_joystickDataMutex);
  m_joystickAxes.swap(m_joystickAxesCache);
  m_joystickPOVs.swap(m_joystickPOVsCache);
  m_joystickButtons.swap(m_joystickButtonsCache);
@@ -629,7 +629,7 @@ void DriverStation::Run() {
 void DriverStation::UpdateControlWord(bool force,
                                      HAL_ControlWord& controlWord) const {
  auto now = std::chrono::steady_clock::now();
-  std::lock_guard<priority_mutex> lock(m_controlWordMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_controlWordMutex);
  // Update every 50 ms or on force.
  if ((now - m_lastControlWordUpdate > std::chrono::milliseconds(50)) ||
      force) {
--- a/wpilibc/athena/src/MotorSafetyHelper.cpp
+++ b/wpilibc/athena/src/MotorSafetyHelper.cpp
@@ -17,7 +17,7 @@
 using namespace frc;

 std::set<MotorSafetyHelper*> MotorSafetyHelper::m_helperList;
-priority_recursive_mutex MotorSafetyHelper::m_listMutex;
+hal::priority_recursive_mutex MotorSafetyHelper::m_listMutex;

 /**
 * The constructor for a MotorSafetyHelper object.
@@ -37,12 +37,12 @@ MotorSafetyHelper::MotorSafetyHelper(MotorSafety* safeObject)
  m_expiration = DEFAULT_SAFETY_EXPIRATION;
  m_stopTime = Timer::GetFPGATimestamp();

-  std::lock_guard<priority_recursive_mutex> sync(m_listMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_listMutex);
  m_helperList.insert(this);
 }

 MotorSafetyHelper::~MotorSafetyHelper() {
-  std::lock_guard<priority_recursive_mutex> sync(m_listMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_listMutex);
  m_helperList.erase(this);
 }

@@ -51,7 +51,7 @@ MotorSafetyHelper::~MotorSafetyHelper() {
 * Resets the timer on this object that is used to do the timeouts.
 */
 void MotorSafetyHelper::Feed() {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  m_stopTime = Timer::GetFPGATimestamp() + m_expiration;
 }

@@ -60,7 +60,7 @@ void MotorSafetyHelper::Feed() {
 * @param expirationTime The timeout value in seconds.
 */
 void MotorSafetyHelper::SetExpiration(double expirationTime) {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  m_expiration = expirationTime;
 }

@@ -69,7 +69,7 @@ void MotorSafetyHelper::SetExpiration(double expirationTime) {
 * @return the timeout value in seconds.
 */
 double MotorSafetyHelper::GetExpiration() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  return m_expiration;
 }

@@ -79,7 +79,7 @@ double MotorSafetyHelper::GetExpiration() const {
 * timed out.
 */
 bool MotorSafetyHelper::IsAlive() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  return !m_enabled || m_stopTime > Timer::GetFPGATimestamp();
 }

@@ -93,7 +93,7 @@ void MotorSafetyHelper::Check() {
  DriverStation& ds = DriverStation::GetInstance();
  if (!m_enabled || ds.IsDisabled() || ds.IsTest()) return;

-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  if (m_stopTime < Timer::GetFPGATimestamp()) {
    std::ostringstream desc;
    m_safeObject->GetDescription(desc);
@@ -109,7 +109,7 @@ void MotorSafetyHelper::Check() {
 * @param enabled True if motor safety is enforced for this object
 */
 void MotorSafetyHelper::SetSafetyEnabled(bool enabled) {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  m_enabled = enabled;
 }

@@ -119,7 +119,7 @@ void MotorSafetyHelper::SetSafetyEnabled(bool enabled) {
 * @return True if motor safety is enforced for this device
 */
 bool MotorSafetyHelper::IsSafetyEnabled() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_syncMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_syncMutex);
  return m_enabled;
 }

@@ -129,7 +129,7 @@ bool MotorSafetyHelper::IsSafetyEnabled() const {
 * any that have timed out.
 */
 void MotorSafetyHelper::CheckMotors() {
-  std::lock_guard<priority_recursive_mutex> sync(m_listMutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_listMutex);
  for (auto elem : m_helperList) {
    elem->Check();
  }
--- a/wpilibc/athena/src/Notifier.cpp
+++ b/wpilibc/athena/src/Notifier.cpp
@@ -14,7 +14,7 @@

 using namespace frc;

-priority_mutex Notifier::m_destructorMutex;
+hal::priority_mutex Notifier::m_destructorMutex;

 /**
 * Create a Notifier for timer event notification.
@@ -44,8 +44,8 @@ Notifier::~Notifier() {
  /* Acquire the mutex; this makes certain that the handler is not being
   * executed by the interrupt manager.
   */
-  std::lock_guard<priority_mutex> lockStatic(Notifier::m_destructorMutex);
-  std::lock_guard<priority_mutex> lock(m_processMutex);
+  std::lock_guard<hal::priority_mutex> lockStatic(Notifier::m_destructorMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_processMutex);
 }

 /**
@@ -68,7 +68,7 @@ void Notifier::Notify(uint64_t currentTimeInt, HAL_NotifierHandle handle) {
  Notifier* notifier;
  {
    // Lock static mutex to grab the notifier param
-    std::lock_guard<priority_mutex> lock(Notifier::m_destructorMutex);
+    std::lock_guard<hal::priority_mutex> lock(Notifier::m_destructorMutex);
    int32_t status = 0;
    auto notifierPointer = HAL_GetNotifierParam(handle, &status);
    if (notifierPointer == nullptr) return;
@@ -95,7 +95,7 @@ void Notifier::Notify(uint64_t currentTimeInt, HAL_NotifierHandle handle) {
 * @param delay Seconds to wait before the handler is called.
 */
 void Notifier::StartSingle(double delay) {
-  std::lock_guard<priority_mutex> sync(m_processMutex);
+  std::lock_guard<hal::priority_mutex> sync(m_processMutex);
  m_periodic = false;
  m_period = delay;
  m_expirationTime = GetClock() + m_period;
@@ -113,7 +113,7 @@ void Notifier::StartSingle(double delay) {
 *               after the call to this method.
 */
 void Notifier::StartPeriodic(double period) {
-  std::lock_guard<priority_mutex> sync(m_processMutex);
+  std::lock_guard<hal::priority_mutex> sync(m_processMutex);
  m_periodic = true;
  m_period = period;
  m_expirationTime = GetClock() + m_period;
@@ -136,6 +136,6 @@ void Notifier::Stop() {

  // Wait for a currently executing handler to complete before returning from
  // Stop()
-  std::lock_guard<priority_mutex> lockStatic(Notifier::m_destructorMutex);
-  std::lock_guard<priority_mutex> lock(m_processMutex);
+  std::lock_guard<hal::priority_mutex> lockStatic(Notifier::m_destructorMutex);
+  std::lock_guard<hal::priority_mutex> lock(m_processMutex);
 }
--- a/wpilibc/athena/src/PIDController.cpp
+++ b/wpilibc/athena/src/PIDController.cpp
@@ -90,7 +90,7 @@ void PIDController::Calculate() {
  PIDOutput* pidOutput;

  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    pidInput = m_pidInput;
    pidOutput = m_pidOutput;
    enabled = m_enabled;
@@ -100,7 +100,7 @@ void PIDController::Calculate() {
  if (pidOutput == nullptr) return;

  if (enabled) {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    double input = pidInput->PIDGet();
    double result;
    PIDOutput* pidOutput;
@@ -197,7 +197,7 @@ double PIDController::CalculateFeedForward() {
 */
 void PIDController::SetPID(double p, double i, double d) {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    m_P = p;
    m_I = i;
    m_D = d;
@@ -222,7 +222,7 @@ void PIDController::SetPID(double p, double i, double d) {
 */
 void PIDController::SetPID(double p, double i, double d, double f) {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    m_P = p;
    m_I = i;
    m_D = d;
@@ -243,7 +243,7 @@ void PIDController::SetPID(double p, double i, double d, double f) {
 * @return proportional coefficient
 */
 double PIDController::GetP() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_P;
 }

@@ -253,7 +253,7 @@ double PIDController::GetP() const {
 * @return integral coefficient
 */
 double PIDController::GetI() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_I;
 }

@@ -263,7 +263,7 @@ double PIDController::GetI() const {
 * @return differential coefficient
 */
 double PIDController::GetD() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_D;
 }

@@ -273,7 +273,7 @@ double PIDController::GetD() const {
 * @return Feed forward coefficient
 */
 double PIDController::GetF() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_F;
 }

@@ -285,7 +285,7 @@ double PIDController::GetF() const {
 * @return the latest calculated output
 */
 double PIDController::Get() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_result;
 }

@@ -299,7 +299,7 @@ double PIDController::Get() const {
 * @param continuous true turns on continuous, false turns off continuous
 */
 void PIDController::SetContinuous(bool continuous) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_continuous = continuous;
 }

@@ -311,7 +311,7 @@ void PIDController::SetContinuous(bool continuous) {
 */
 void PIDController::SetInputRange(double minimumInput, double maximumInput) {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    m_minimumInput = minimumInput;
    m_maximumInput = maximumInput;
  }
@@ -326,7 +326,7 @@ void PIDController::SetInputRange(double minimumInput, double maximumInput) {
 * @param maximumOutput the maximum value to write to the output
 */
 void PIDController::SetOutputRange(double minimumOutput, double maximumOutput) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_minimumOutput = minimumOutput;
  m_maximumOutput = maximumOutput;
 }
@@ -340,7 +340,7 @@ void PIDController::SetOutputRange(double minimumOutput, double maximumOutput) {
 */
 void PIDController::SetSetpoint(double setpoint) {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);

    if (m_maximumInput > m_minimumInput) {
      if (setpoint > m_maximumInput)
@@ -369,7 +369,7 @@ void PIDController::SetSetpoint(double setpoint) {
 * @return the current setpoint
 */
 double PIDController::GetSetpoint() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_setpoint;
 }

@@ -379,7 +379,7 @@ double PIDController::GetSetpoint() const {
 * @return the change in setpoint over time
 */
 double PIDController::GetDeltaSetpoint() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return (m_setpoint - m_prevSetpoint) / m_setpointTimer.Get();
 }

@@ -391,7 +391,7 @@ double PIDController::GetDeltaSetpoint() const {
 double PIDController::GetError() const {
  double setpoint = GetSetpoint();
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    return GetContinuousError(setpoint - m_pidInput->PIDGet());
  }
 }
@@ -422,7 +422,7 @@ PIDSourceType PIDController::GetPIDSourceType() const {
 double PIDController::GetAvgError() const {
  double avgError = 0;
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    // Don't divide by zero.
    if (m_buf.size()) avgError = m_bufTotal / m_buf.size();
  }
@@ -436,7 +436,7 @@ double PIDController::GetAvgError() const {
 * @param percentage error which is tolerable
 */
 void PIDController::SetTolerance(double percent) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_toleranceType = kPercentTolerance;
  m_tolerance = percent;
 }
@@ -448,7 +448,7 @@ void PIDController::SetTolerance(double percent) {
 * @param percentage error which is tolerable
 */
 void PIDController::SetAbsoluteTolerance(double absTolerance) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_toleranceType = kAbsoluteTolerance;
  m_tolerance = absTolerance;
 }
@@ -460,7 +460,7 @@ void PIDController::SetAbsoluteTolerance(double absTolerance) {
 * @param percentage error which is tolerable
 */
 void PIDController::SetPercentTolerance(double percent) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_toleranceType = kPercentTolerance;
  m_tolerance = percent;
 }
@@ -476,7 +476,7 @@ void PIDController::SetPercentTolerance(double percent) {
 * @param bufLength Number of previous cycles to average. Defaults to 1.
 */
 void PIDController::SetToleranceBuffer(int bufLength) {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_bufLength = bufLength;

  // Cut the buffer down to size if needed.
@@ -498,7 +498,7 @@ void PIDController::SetToleranceBuffer(int bufLength) {
 * This will return false until at least one input value has been computed.
 */
 bool PIDController::OnTarget() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  if (m_buf.size() == 0) return false;
  double error = GetAvgError();
  switch (m_toleranceType) {
@@ -521,7 +521,7 @@ bool PIDController::OnTarget() const {
 */
 void PIDController::Enable() {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    m_enabled = true;
  }

@@ -535,7 +535,7 @@ void PIDController::Enable() {
 */
 void PIDController::Disable() {
  {
-    std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
    m_pidOutput->PIDWrite(0);
    m_enabled = false;
  }
@@ -549,7 +549,7 @@ void PIDController::Disable() {
 * Return true if PIDController is enabled.
 */
 bool PIDController::IsEnabled() const {
-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  return m_enabled;
 }

@@ -559,7 +559,7 @@ bool PIDController::IsEnabled() const {
 void PIDController::Reset() {
  Disable();

-  std::lock_guard<priority_recursive_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_recursive_mutex> sync(m_mutex);
  m_prevError = 0;
  m_totalError = 0;
  m_result = 0;
--- a/wpilibc/athena/src/Timer.cpp
+++ b/wpilibc/athena/src/Timer.cpp
@@ -80,7 +80,7 @@ double Timer::Get() const {
  double result;
  double currentTime = GetFPGATimestamp();

-  std::lock_guard<priority_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_mutex> sync(m_mutex);
  if (m_running) {
    // If the current time is before the start time, then the FPGA clock
    // rolled over.  Compensate by adding the ~71 minutes that it takes
@@ -104,7 +104,7 @@ double Timer::Get() const {
 * now.
 */
 void Timer::Reset() {
-  std::lock_guard<priority_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_mutex> sync(m_mutex);
  m_accumulatedTime = 0;
  m_startTime = GetFPGATimestamp();
 }
@@ -116,7 +116,7 @@ void Timer::Reset() {
 * relative to the system clock.
 */
 void Timer::Start() {
-  std::lock_guard<priority_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_mutex> sync(m_mutex);
  if (!m_running) {
    m_startTime = GetFPGATimestamp();
    m_running = true;
@@ -133,7 +133,7 @@ void Timer::Start() {
 void Timer::Stop() {
  double temp = Get();

-  std::lock_guard<priority_mutex> sync(m_mutex);
+  std::lock_guard<hal::priority_mutex> sync(m_mutex);
  if (m_running) {
    m_accumulatedTime = temp;
    m_running = false;
@@ -150,7 +150,7 @@ void Timer::Stop() {
 */
 bool Timer::HasPeriodPassed(double period) {
  if (Get() > period) {
-    std::lock_guard<priority_mutex> sync(m_mutex);
+    std::lock_guard<hal::priority_mutex> sync(m_mutex);
    // Advance the start time by the period.
    m_startTime += period;
    // Don't set it to the current time... we want to avoid drift.