AdcManager.h

Go to the documentation of this file.

 
#ifndef VORTEX_ADC_MANAGER_H_
#define VORTEX_ADC_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <optional>
#include <string_view>
 
#include "base/BaseAdc.h"
#include "RtosMutex.h"
#include "handlers/tmc9660/Tmc9660AdcWrapper.h"
#include "core/hf-core-drivers/internal/hf-pincfg/src/hf_functional_pin_config_vortex_v1.hpp"
 
// Forward declarations
class MotorController;
class Tmc9660Handler;
 
//==============================================================================
// ADC ENTRY
//==============================================================================
 
struct AdcEntry {
    HfFunctionalAdcChannel functional_channel{HfFunctionalAdcChannel::HF_FUNCTIONAL_ADC_COUNT}; 
    std::string_view name;              
    BaseAdc* driver{nullptr};           
    uint8_t adc_unit{0};                
    uint8_t hw_channel{0};              
    float voltage_divider{1.0f};        
    bool registered{false};             
 
    // Statistics
    uint32_t access_count{0};           
    uint32_t error_count{0};            
};
 
//==============================================================================
// ADC SYSTEM DIAGNOSTICS
//==============================================================================
 
struct AdcSystemDiagnostics {
    bool system_healthy{false};                 
    uint32_t total_channels_registered{0};      
    uint32_t channels_by_chip[2]{};             
    uint32_t total_operations{0};               
    uint32_t successful_operations{0};          
    uint32_t failed_operations{0};              
    uint32_t communication_errors{0};           
    uint32_t hardware_errors{0};                
    uint64_t system_uptime_ms{0};               
    hf_adc_err_t last_error{hf_adc_err_t::ADC_SUCCESS}; 
};
 
//==============================================================================
// ADC MANAGER
//==============================================================================
 
class AdcManager {
public:
    //==========================================================================
    // SINGLETON AND LIFECYCLE
    //==========================================================================
 
    static AdcManager& GetInstance() noexcept;
 
    AdcManager(const AdcManager&) = delete;
    AdcManager& operator=(const AdcManager&) = delete;
    AdcManager(AdcManager&&) = delete;
    AdcManager& operator=(AdcManager&&) = delete;
 
    [[nodiscard]] bool EnsureInitialized() noexcept;
 
    [[nodiscard]] bool Deinitialize() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    //==========================================================================
    // CHANNEL ACCESS
    //==========================================================================
 
    [[nodiscard]] BaseAdc* Get(std::string_view name) noexcept;
 
    [[nodiscard]] BaseAdc* Get(HfFunctionalAdcChannel channel) noexcept;
 
    [[nodiscard]] bool Contains(std::string_view name) const noexcept;
 
    [[nodiscard]] size_t Size() const noexcept;
 
    //==========================================================================
    // READING OPERATIONS
    //==========================================================================
 
    [[nodiscard]] hf_adc_err_t ReadVoltage(std::string_view name, float& voltage,
                                           hf_u8_t samples = 1,
                                           hf_time_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadVoltage(HfFunctionalAdcChannel channel, float& voltage,
                                           hf_u8_t samples = 1,
                                           hf_time_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadRaw(std::string_view name, uint32_t& raw_value,
                                       hf_u8_t numOfSamplesToAvg = 1,
                                       hf_time_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadRaw(HfFunctionalAdcChannel channel, uint32_t& raw_value,
                                       hf_u8_t numOfSamplesToAvg = 1,
                                       hf_time_t timeBetweenSamples = 0) noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    [[nodiscard]] hf_adc_err_t GetSystemDiagnostics(AdcSystemDiagnostics& diagnostics) const noexcept;
 
    [[nodiscard]] hf_adc_err_t GetLastError() const noexcept { return last_error_.load(std::memory_order_acquire); }
 
    void DumpStatistics() const noexcept;
 
private:
    AdcManager() noexcept = default;
    ~AdcManager();
 
    bool Initialize() noexcept;
 
    [[nodiscard]] size_t FindByName(std::string_view name) const noexcept;
 
    [[nodiscard]] size_t FindByEnum(HfFunctionalAdcChannel channel) const noexcept;
 
    //==========================================================================
    // STORAGE — entries are fixed-size; the Tmc9660AdcWrapper lives in place
    //           (std::optional, emplaced at init, reset at deinit)
    //==========================================================================
 
    static constexpr size_t kMaxChannels =
        static_cast<size_t>(HfFunctionalAdcChannel::HF_FUNCTIONAL_ADC_COUNT);
    static constexpr size_t kInvalidIndex = SIZE_MAX;
 
    std::array<AdcEntry, kMaxChannels> entries_{};
    size_t registered_count_{0};
 
    std::optional<Tmc9660AdcWrapper> tmc9660_adc_;   
 
    MotorController* motor_controller_{nullptr};
 
    std::atomic<bool> initialized_{false};
    std::atomic<hf_adc_err_t> last_error_{hf_adc_err_t::ADC_SUCCESS};
    std::atomic<bool> warned_motor_controller_not_ready_{false};
    std::atomic<bool> warned_tmc_handler_missing_{false};
    mutable RtosMutex mutex_;
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline AdcManager& GetAdcManager() noexcept {
    return AdcManager::GetInstance();
}
 
#endif // VORTEX_ADC_MANAGER_H_