AdcManager.h

Go to the documentation of this file.

 
#ifndef FLUX_ADC_MANAGER_H_
#define FLUX_ADC_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <optional>
#include <string_view>
 
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseAdc.h"
#include "RtosMutex.h"
#include "flux_hal/flux_hal_types.hpp"
#include "handlers/ads7952/Ads7952Handler.h"
#include "core/hf-core-drivers/internal/hf-pincfg/src/hf_functional_pin_config_flux_v1.hpp"
 
 
//==============================================================================
// ADC ENTRY — fixed-size registry; the MCU ADC object lives in the platform
//              binding's static storage
//==============================================================================
 
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};            
};
 
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 IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    [[nodiscard]] flux::hal::ManagerError GetManagerError() const noexcept {
        return manager_error_.load(std::memory_order_acquire);
    }
 
    [[nodiscard]] bool IsInternalAdcReady() const noexcept { return internal_adc_ != nullptr; }
 
    [[nodiscard]] bool IsAds7952Ready(uint8_t device_index) const noexcept;
 
    [[nodiscard]] bool Deinitialize() noexcept;
 
    //==========================================================================
    // 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,
                                           uint8_t samples = 1,
                                           uint16_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadVoltage(HfFunctionalAdcChannel channel, float& voltage,
                                           uint8_t samples = 1,
                                           uint16_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadRaw(std::string_view name, uint32_t& raw_count,
                                       uint8_t samples = 1,
                                       uint16_t timeBetweenSamples = 0) noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadRaw(HfFunctionalAdcChannel channel, uint32_t& raw_count,
                                       uint8_t samples = 1,
                                       uint16_t timeBetweenSamples = 0) noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    [[nodiscard]] hf_adc_err_t GetLastError() const noexcept { return last_error_.load(std::memory_order_acquire); }
 
    [[nodiscard]] hf_adc_err_t GetSystemDiagnostics(AdcSystemDiagnostics& diag) const noexcept;
 
    void DumpStatistics() const noexcept;
 
private:
    AdcManager() noexcept = default;
    ~AdcManager() = default;
 
    bool Initialize() noexcept;
 
    void ReleaseLocked() noexcept;
 
    [[nodiscard]] size_t FindByName(std::string_view name) const noexcept;
 
    [[nodiscard]] size_t FindByEnum(HfFunctionalAdcChannel channel) const noexcept;
 
    [[nodiscard]] hf_adc_err_t ReadVoltageByIndex(size_t idx, float& voltage, uint8_t samples, uint16_t timeBetweenSamples) noexcept;
    [[nodiscard]] hf_adc_err_t ReadRawByIndex(size_t idx, uint32_t& raw_count, uint8_t samples, uint16_t timeBetweenSamples) noexcept;
 
    //==========================================================================
    // STORAGE — entries are fixed-size in static storage; the MCU ADC is
    //           owned by the platform binding
    //==========================================================================
 
    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_{};
    std::array<size_t, kMaxChannels> enum_to_index_{}; 
    size_t registered_count_{0};
    uint64_t init_time_ms_{0};  
 
    // MCU ADC unit (ADC1) — owned by the platform binding (bsp_bind), nullptr when down.
    BaseAdc* internal_adc_{nullptr};
 
    // ADS7952 external ADC handler(s) — members, constructed in place at bring-up
    // (no heap). One slot per possible device on the pressure bus (one fitted on
    // Flux V1, room for expansion). Unconditional, so every translation unit sees
    // the same class layout whatever the HAL's private feature macros are.
    static constexpr size_t kMaxAds7952Devices = 4;
    std::array<std::optional<Ads7952Handler>, kMaxAds7952Devices> ads7952_handlers_{};
    size_t ads7952_device_count_{0};
 
    std::atomic<bool> initialized_{false};
    std::atomic<flux::hal::ManagerError> manager_error_{flux::hal::ManagerError::NotInitialized};
    std::atomic<hf_adc_err_t> last_error_{hf_adc_err_t::ADC_SUCCESS};
    mutable RtosMutex mutex_;
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline AdcManager& GetAdcManager() noexcept {
    return AdcManager::GetInstance();
}
 
#endif // FLUX_ADC_MANAGER_H_