GpioManager.h

Go to the documentation of this file.

 
#ifndef FLUX_GPIO_MANAGER_H_
#define FLUX_GPIO_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <string_view>
 
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseGpio.h"
#include "RtosMutex.h"
#include "flux_hal/flux_hal_types.hpp"
#include "core/hf-core-drivers/internal/hf-pincfg/src/hf_functional_pin_config_flux_v1.hpp"
 
//==============================================================================
// GPIO ENTRY
//==============================================================================
 
struct GpioEntry {
    BaseGpio* driver;                   
    HfFunctionalGpioPin functional_pin; 
    bool registered{false};             
    uint32_t access_count{0};           
    uint32_t error_count{0};            
 
    GpioEntry() noexcept
        : driver(nullptr), functional_pin(HfFunctionalGpioPin::HF_FUNCTIONAL_GPIO_COUNT) {}
};
 
//==============================================================================
// GPIO SYSTEM DIAGNOSTICS
//==============================================================================
 
struct GpioSystemDiagnostics {
    bool system_healthy;               
    uint32_t total_pins_registered;    
    uint32_t total_operations;         
    uint32_t successful_operations;    
    uint32_t failed_operations;        
    uint64_t system_uptime_ms;         
    hf_gpio_err_t last_error;          
};
 
//==============================================================================
// GPIO MANAGER
//==============================================================================
 
class GpioManager {
public:
    //==========================================================================
    // SINGLETON AND LIFECYCLE
    //==========================================================================
 
    static GpioManager& GetInstance() noexcept;
 
    GpioManager(const GpioManager&) = delete;
    GpioManager& operator=(const GpioManager&) = delete;
    GpioManager(GpioManager&&) = delete;
    GpioManager& operator=(GpioManager&&) = delete;
 
    [[nodiscard]] bool EnsureInitialized() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    [[nodiscard]] bool Deinitialize() noexcept;
 
    [[nodiscard]] hf_gpio_err_t GetLastError() const noexcept { return last_error_; }
 
    [[nodiscard]] flux::hal::ManagerError GetManagerError() const noexcept {
        return manager_error_.load(std::memory_order_acquire);
    }
 
    //==========================================================================
    // GPIO ACCESS — by string name
    //==========================================================================
 
    [[nodiscard]] BaseGpio* Get(std::string_view name) noexcept;
 
    [[nodiscard]] BaseGpio* Get(HfFunctionalGpioPin pin) noexcept;
 
    [[nodiscard]] bool Contains(std::string_view name) const noexcept;
 
    [[nodiscard]] size_t Size() const noexcept;
 
    //==========================================================================
    // BASIC GPIO OPERATIONS — string-based routing
    //==========================================================================
 
    [[nodiscard]] hf_gpio_err_t Set(std::string_view name, bool value) noexcept;
 
    [[nodiscard]] hf_gpio_err_t SetActive(std::string_view name) noexcept;
 
    [[nodiscard]] hf_gpio_err_t SetInactive(std::string_view name) noexcept;
 
    [[nodiscard]] hf_gpio_err_t Read(std::string_view name, bool& state) noexcept;
 
    [[nodiscard]] hf_gpio_err_t Toggle(std::string_view name) noexcept;
 
    [[nodiscard]] hf_gpio_err_t IsActive(std::string_view name, bool& active) noexcept;
 
    //==========================================================================
    // PIN CONFIGURATION
    //==========================================================================
 
    [[nodiscard]] hf_gpio_err_t SetDirection(std::string_view name, hf_gpio_direction_t direction) noexcept;
 
    [[nodiscard]] hf_gpio_err_t SetPullMode(std::string_view name, hf_gpio_pull_mode_t pull_mode) noexcept;
 
    [[nodiscard]] hf_gpio_err_t SetOutputMode(std::string_view name, hf_gpio_output_mode_t mode) noexcept;
 
    //==========================================================================
    // INTERRUPT SUPPORT — forwarded to underlying BaseGpio driver
    //==========================================================================
 
    [[nodiscard]] hf_gpio_err_t ConfigureInterrupt(std::string_view name,
                                                   hf_gpio_interrupt_trigger_t trigger,
                                                   InterruptCallback callback,
                                                   void* user_data = nullptr) noexcept;
    [[nodiscard]] hf_gpio_err_t EnableInterrupt(std::string_view name) noexcept;
 
    [[nodiscard]] hf_gpio_err_t DisableInterrupt(std::string_view name) noexcept;
 
    [[nodiscard]] bool SupportsInterrupts(std::string_view name) const noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    [[nodiscard]] hf_gpio_err_t GetSystemDiagnostics(GpioSystemDiagnostics& diagnostics) const noexcept;
 
    void DumpStatistics() const noexcept;
 
private:
    GpioManager() noexcept = default;
    ~GpioManager() = default;
 
    bool Initialize() noexcept;
    void ReleaseLocked() noexcept;
 
    [[nodiscard]] size_t FindByName(std::string_view name) const noexcept;
 
    static constexpr size_t kMaxEntries = static_cast<size_t>(HfFunctionalGpioPin::HF_FUNCTIONAL_GPIO_COUNT);
    static constexpr size_t kInvalidIndex = SIZE_MAX;
 
    std::array<GpioEntry, kMaxEntries> entries_{};
    size_t registered_count_{0};
    uint64_t init_time_ms_{0};  
 
    uint32_t total_ops_{0};
    uint32_t successful_ops_{0};
    uint32_t failed_ops_{0};
    hf_gpio_err_t last_error_{hf_gpio_err_t::GPIO_SUCCESS};
 
    std::atomic<bool> initialized_{false};
    std::atomic<flux::hal::ManagerError> manager_error_{flux::hal::ManagerError::NotInitialized};
    mutable RtosMutex mutex_;
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline GpioManager& GetGpioManager() noexcept {
    return GpioManager::GetInstance();
}
 
#endif // FLUX_GPIO_MANAGER_H_