GpioManager.h

Go to the documentation of this file.

 
#ifndef VORTEX_GPIO_MANAGER_H_
#define VORTEX_GPIO_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <optional>
#include <string_view>
 
#include "base/BaseGpio.h"
#include "handlers/pcal95555/Pcal95555Handler.h"
#include "RtosMutex.h"
#include "core/hf-core-drivers/internal/hf-pincfg/src/hf_functional_pin_config_vortex_v1.hpp"
 
//==============================================================================
// FORWARD DECLARATIONS
//==============================================================================
 
class Pcal95555Handler;
class Tmc9660Handler;
class MotorController;
 
//==============================================================================
// GPIO ENTRY — one slot per pin in the fixed-size array
//==============================================================================
 
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) {}
};
 
//==============================================================================
// DIAGNOSTICS STRUCTURE
//==============================================================================
 
struct GpioSystemDiagnostics {
    bool system_healthy;               
    uint32_t total_pins_registered;    
    uint32_t pins_by_chip[static_cast<uint8_t>(HfGpioChipType::TMC9660_CONTROLLER) + 1]; 
    uint32_t pins_by_category[4];      
    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 Deinitialize() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    //==========================================================================
    // GPIO ACCESS — by string name or functional enum
    //==========================================================================
 
    [[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;
 
    [[nodiscard]] hf_gpio_err_t DebugReadPcal95555Pin(uint8_t expander_pin_0_to_15,
                                                      bool& out_level) noexcept;
 
    [[nodiscard]] hf_gpio_err_t DebugReadPcal95555InputSnapshot(uint16_t& out_bits) noexcept;
 
    void RegisterTmc9660BridgePinsIfNeeded() noexcept;
 
    void UnregisterTmc9660BridgePins() 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;
 
    [[nodiscard]] hf_gpio_err_t GetLastError() const noexcept { return last_error_; }
 
    void DumpStatistics() const noexcept;
 
private:
    GpioManager() noexcept = default;
    ~GpioManager() = default;
 
    [[nodiscard]] bool Initialize() noexcept;
 
    void ReleaseLocked() noexcept;
 
    [[nodiscard]] size_t FindByName(std::string_view name) const noexcept;
 
    [[nodiscard]] bool EnsurePcal95555Handler() noexcept;
 
 
    //--------------------------------------------------------------------------
    // Storage
    //--------------------------------------------------------------------------
 
    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};
    mutable RtosMutex mutex_;
 
    //--------------------------------------------------------------------------
    // Hardware handlers
    //--------------------------------------------------------------------------
 
    std::optional<Pcal95555Handler> pcal95555_handler_;                  
    std::array<std::optional<Pcal95555GpioPin>, 16> pcal_pins_{};       
    BaseGpio* pcal_host_int_gpio_{nullptr};   
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline GpioManager& GetGpioManager() noexcept {
    return GpioManager::GetInstance();
}
 
#endif // VORTEX_GPIO_MANAGER_H_