RtosMutex.h

Go to the documentation of this file.

 
#pragma once
 
#include "OsAbstraction.h"
#include "OsUtility.h"
 
#include <atomic>
#include <cstdint>
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RtosTime — high-resolution timing utilities
 * ═══════════════════════════════════════════════════════════════════════════ */
 
class RtosTime {
public:
  static uint64_t GetCurrentTimeUs() noexcept {
#if (defined(HF_RTOS_NONE) || defined(HF_MCU_FAMILY_NONE)) && defined(HF_RTOS_NONE_EXTERNAL_CLOCK)
    return hf_os_none_clock_us();
#elif defined(HF_RTOS_NONE) || defined(HF_MCU_FAMILY_NONE)
    return 0;
#else
    const uint32_t ticks = static_cast<uint32_t>(os_time_get());
    return static_cast<uint64_t>(os_convert_delay_ticks_to_msec(ticks)) * 1000ULL;
#endif
  }
 
  static uint32_t MsToTicks(uint32_t ms) noexcept {
    if (ms == 0) {
      return 0;
    }
    const uint32_t ticks = os_convert_msec_to_delay_ticks(ms);
    return (ticks > 0) ? ticks : 1;
  }
};
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RtosMutex — recursive mutex built on OsAbstraction
 * ═══════════════════════════════════════════════════════════════════════════ */
 
class RtosMutex {
public:
  RtosMutex() noexcept;
 
  ~RtosMutex() noexcept;
 
  RtosMutex(const RtosMutex&) = delete;
  RtosMutex& operator=(const RtosMutex&) = delete;
 
  RtosMutex(RtosMutex&& other) noexcept;
 
  RtosMutex& operator=(RtosMutex&& other) noexcept;
 
  bool lock() noexcept;
 
  bool try_lock() noexcept;
 
  bool try_lock_for(uint32_t timeout_ms) noexcept;
 
  void unlock() noexcept;
 
  OS_Mutex native_handle() const noexcept {
    return handle_;
  }
 
  // ── Convenience FreeRTOS-style API ──────────────────────────────────────
 
  bool Take(uint32_t timeout_ms = 0) noexcept {
    if (timeout_ms > 0) {
      return try_lock_for(timeout_ms);
    }
    return lock();
  }
 
  void Give() noexcept {
    unlock();
  }
 
  // ── Shared lock methods (delegated to regular mutex for simplicity) ─────
 
  bool lock_shared() noexcept { return lock(); }
  bool try_lock_shared() noexcept { return try_lock(); }
  bool try_lock_shared_for(uint32_t timeout_ms) noexcept { return try_lock_for(timeout_ms); }
  void unlock_shared() noexcept { unlock(); }
 
private:
  OS_Mutex handle_;
};
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RtosSharedMutex — reader-writer mutex
 *
 * Provides shared (read) and exclusive (write) locking semantics.
 * Uses two underlying OS mutexes for writer exclusion and reader counting.
 * ═══════════════════════════════════════════════════════════════════════════ */
 
class RtosSharedMutex {
public:
  RtosSharedMutex() noexcept;
 
  ~RtosSharedMutex() noexcept;
 
  RtosSharedMutex(const RtosSharedMutex&) = delete;
  RtosSharedMutex& operator=(const RtosSharedMutex&) = delete;
 
  RtosSharedMutex(RtosSharedMutex&& other) noexcept;
 
  RtosSharedMutex& operator=(RtosSharedMutex&& other) noexcept;
 
  bool lock() noexcept;
 
  bool try_lock() noexcept;
 
  bool try_lock_for(uint32_t timeout_ms) noexcept;
 
  void unlock() noexcept;
 
  bool lock_shared() noexcept;
 
  bool try_lock_shared() noexcept;
 
  bool try_lock_shared_for(uint32_t timeout_ms) noexcept;
 
  void unlock_shared() noexcept;
 
private:
  OS_Mutex writer_mutex_;
  OS_Mutex reader_mutex_;
  std::atomic<int> readers_;
  std::atomic<bool> writer_active_;
};
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RtosUniqueLock — RAII exclusive lock (similar to std::unique_lock)
 * ═══════════════════════════════════════════════════════════════════════════ */
 
template <typename MutexT>
class RtosUniqueLock {
public:
  explicit RtosUniqueLock(MutexT& mutex, uint32_t timeout_ms = 0) noexcept
      : mutex_(&mutex), locked_(false) {
    if (timeout_ms > 0) {
      locked_ = mutex_->try_lock_for(timeout_ms);
    } else {
      locked_ = mutex_->lock();
    }
  }
 
  ~RtosUniqueLock() noexcept {
    if (locked_ && mutex_) {
      mutex_->unlock();
    }
  }
 
  RtosUniqueLock(const RtosUniqueLock&) = delete;
  RtosUniqueLock& operator=(const RtosUniqueLock&) = delete;
 
  RtosUniqueLock(RtosUniqueLock&& other) noexcept : mutex_(other.mutex_), locked_(other.locked_) {
    other.mutex_ = nullptr;
    other.locked_ = false;
  }
 
  RtosUniqueLock& operator=(RtosUniqueLock&& other) noexcept {
    if (this != &other) {
      if (locked_ && mutex_) {
        mutex_->unlock();
      }
      mutex_ = other.mutex_;
      locked_ = other.locked_;
      other.mutex_ = nullptr;
      other.locked_ = false;
    }
    return *this;
  }
 
  [[nodiscard]] bool IsLocked() const noexcept {
    return locked_;
  }
 
  void Unlock() noexcept {
    if (locked_ && mutex_) {
      mutex_->unlock();
      locked_ = false;
    }
  }
 
private:
  MutexT* mutex_;
  bool locked_;
};
 
/* ═══════════════════════════════════════════════════════════════════════════
 * RtosSharedLock — RAII shared (reader) lock
 * ═══════════════════════════════════════════════════════════════════════════ */
 
template <typename SharedMutexT>
class RtosSharedLock {
public:
  explicit RtosSharedLock(SharedMutexT& mutex, uint32_t timeout_ms = 0) noexcept
      : mutex_(&mutex), locked_(false) {
    if (timeout_ms > 0) {
      locked_ = mutex_->try_lock_shared_for(timeout_ms);
    } else {
      locked_ = mutex_->lock_shared();
    }
  }
 
  ~RtosSharedLock() noexcept {
    if (locked_ && mutex_) {
      mutex_->unlock_shared();
    }
  }
 
  RtosSharedLock(const RtosSharedLock&) = delete;
  RtosSharedLock& operator=(const RtosSharedLock&) = delete;
 
  RtosSharedLock(RtosSharedLock&& other) noexcept : mutex_(other.mutex_), locked_(other.locked_) {
    other.mutex_ = nullptr;
    other.locked_ = false;
  }
 
  RtosSharedLock& operator=(RtosSharedLock&& other) noexcept {
    if (this != &other) {
      if (locked_ && mutex_) {
        mutex_->unlock_shared();
      }
      mutex_ = other.mutex_;
      locked_ = other.locked_;
      other.mutex_ = nullptr;
      other.locked_ = false;
    }
    return *this;
  }
 
  [[nodiscard]] bool IsLocked() const noexcept {
    return locked_;
  }
 
  void Unlock() noexcept {
    if (locked_ && mutex_) {
      mutex_->unlock_shared();
      locked_ = false;
    }
  }
 
private:
  SharedMutexT* mutex_;
  bool locked_;
};
 
/* ═══════════════════════════════════════════════════════════════════════════
 * Convenience Type Aliases
 * ═══════════════════════════════════════════════════════════════════════════ */
 
template <typename MutexT>
using RtosLockGuard = RtosUniqueLock<MutexT>;
 
using MutexLockGuard = RtosUniqueLock<RtosMutex>;