Ads7952Handler.h

Go to the documentation of this file.

 
#ifndef COMPONENT_HANDLER_ADS7952_HANDLER_H_
#define COMPONENT_HANDLER_ADS7952_HANDLER_H_
 
#include <cstdint>
#include <memory>
#include <type_traits>
#include <utility>
#include "core/hf-core-drivers/external/hf-ads7952-driver/inc/ads7952.hpp"
#include "base/BaseSpi.h"
#include "base/BaseAdc.h"
#include "RtosMutex.h"
 
//======================================================//
// ADS7952 SPI BRIDGE ADAPTER (CRTP — zero virtual overhead)
//======================================================//
 
class Ads7952SpiAdapter : public ads7952::SpiInterface<Ads7952SpiAdapter> {
public:
    explicit Ads7952SpiAdapter(BaseSpi& spi_interface) noexcept;
 
    bool transfer(const uint8_t* tx, uint8_t* rx, std::size_t len) noexcept;
 
private:
    BaseSpi& spi_interface_;
};
 
//======================================================//
// ADS7952 HANDLER CONFIGURATION
//======================================================//
 
struct Ads7952HandlerConfig {
    float vref;                       
    float va;                         
    ads7952::Range range;             
    ads7952::Mode initial_mode;       
    uint16_t auto1_channel_mask;      
    uint8_t auto2_last_channel;       
    uint8_t device_index;             
};
 
inline Ads7952HandlerConfig GetDefaultAds7952Config() noexcept {
    return Ads7952HandlerConfig{
        .vref                = 2.5f,
        .va                  = 5.0f,
        .range               = ads7952::Range::TwoVref,
        .initial_mode        = ads7952::Mode::Manual,
        .auto1_channel_mask  = ads7952::kAllChannels,
        .auto2_last_channel  = 11,
        .device_index        = 0
    };
}
 
//======================================================//
// ADS7952 HANDLER DIAGNOSTICS
//======================================================//
 
struct Ads7952Diagnostics {
    bool initialized;                 
    bool driver_ready;                
    ads7952::Mode current_mode;       
    ads7952::Range current_range;     
    float vref;                       
    float active_vref;                
    uint32_t total_reads;             
    uint32_t error_count;             
    uint8_t device_index;             
};
 
//======================================================//
// ADS7952 HANDLER CLASS — implements BaseAdc
//======================================================//
 
class Ads7952Handler : public BaseAdc {
public:
    //======================================================//
    // CONSTRUCTION AND LIFECYCLE
    //======================================================//
 
    explicit Ads7952Handler(BaseSpi& spi_interface,
                            const Ads7952HandlerConfig& config = GetDefaultAds7952Config()) noexcept;
 
    ~Ads7952Handler() noexcept override = default;
 
    // Non-copyable, non-movable
    Ads7952Handler(const Ads7952Handler&) = delete;
    Ads7952Handler& operator=(const Ads7952Handler&) = delete;
    Ads7952Handler(Ads7952Handler&&) = delete;
    Ads7952Handler& operator=(Ads7952Handler&&) = delete;
 
    //======================================================//
    // BaseAdc INTERFACE IMPLEMENTATION
    //======================================================//
 
    bool Initialize() noexcept override;
 
    bool Deinitialize() noexcept override;
 
    hf_u8_t GetMaxChannels() const noexcept override;
 
    bool IsChannelAvailable(hf_channel_id_t channel) const noexcept override;
 
    hf_adc_err_t ReadChannelV(hf_channel_id_t channel, float& voltage,
                              hf_u8_t samples = 1, hf_time_t timeout_ms = 0) noexcept override;
 
    hf_adc_err_t ReadChannelCount(hf_channel_id_t channel, hf_u32_t& count,
                                  hf_u8_t samples = 1, hf_time_t timeout_ms = 0) noexcept override;
 
    hf_adc_err_t ReadChannel(hf_channel_id_t channel, hf_u32_t& count, float& voltage,
                             hf_u8_t samples = 1, hf_time_t timeout_ms = 0) noexcept override;
 
    hf_adc_err_t ReadMultipleChannels(const hf_channel_id_t* channels, hf_u8_t num_channels,
                                      hf_u32_t* counts, float* voltages) noexcept override;
 
    //======================================================//
    // ADS7952-SPECIFIC METHODS
    //======================================================//
 
    bool ReadAllChannels(ads7952::ChannelReadings& readings) noexcept;
 
    bool ReadAuto1Channels(uint16_t mask,
                           ads7952::ChannelReadings& readings) noexcept;
 
    uint8_t RawManualFrames(uint8_t channel, uint16_t* out, uint8_t n) noexcept;
 
    bool ProgramAlarm(uint8_t channel, ads7952::AlarmBound bound, uint16_t threshold_12bit) noexcept;
 
    bool ProgramAlarmVoltage(uint8_t channel, ads7952::AlarmBound bound, float voltage) noexcept;
 
    bool SetRange(ads7952::Range range) noexcept;
 
    float GetActiveVref() const noexcept;
 
    //======================================================//
    // DRIVER ACCESS
    //======================================================//
 
    ads7952::ADS7952<Ads7952SpiAdapter>* GetDriver() noexcept;
    const ads7952::ADS7952<Ads7952SpiAdapter>* GetDriver() const noexcept;
 
    template <typename Fn>
    auto visitDriver(Fn&& fn) noexcept -> decltype(fn(std::declval<ads7952::ADS7952<Ads7952SpiAdapter>&>())) {
        using ReturnType = decltype(fn(std::declval<ads7952::ADS7952<Ads7952SpiAdapter>&>()));
        MutexLockGuard lock(handler_mutex_);
        if (!EnsureInitializedLocked() || !adc_driver_) {
            if constexpr (std::is_void_v<ReturnType>) {
                return;
            } else {
                return ReturnType{};
            }
        }
        return fn(*adc_driver_);
    }
 
    //======================================================//
    // DIAGNOSTICS
    //======================================================//
 
    const char* GetDescription() const noexcept;
 
    bool GetHandlerDiagnostics(Ads7952Diagnostics& diag) const noexcept;
 
    void DumpDiagnostics() const noexcept;
 
    uint8_t GetDeviceIndex() const noexcept { return config_.device_index; }
 
private:
    //======================================================//
    // PRIVATE MEMBERS
    //======================================================//
 
    BaseSpi& spi_ref_;                                
    std::unique_ptr<Ads7952SpiAdapter> spi_adapter_;  
    std::unique_ptr<ads7952::ADS7952<Ads7952SpiAdapter>> adc_driver_;  
    Ads7952HandlerConfig config_;                     
    mutable RtosMutex handler_mutex_;                 
    char description_[64];                            
 
    // Statistics
    mutable uint32_t total_reads_{0};                 
    mutable uint32_t error_count_{0};                 
 
    //======================================================//
    // PRIVATE HELPERS
    //======================================================//
 
    bool EnsureInitializedLocked() noexcept;
 
    bool ApplyConfiguration() noexcept;
 
    ads7952::ReadResult ReadChannelLocked(uint8_t channel) noexcept;
};
 
//======================================================//
// FACTORY METHODS
//======================================================//
 
std::unique_ptr<Ads7952Handler> CreateAds7952Handler(
    BaseSpi& spi_interface,
    const Ads7952HandlerConfig& config = GetDefaultAds7952Config()) noexcept;
 
#endif // COMPONENT_HANDLER_ADS7952_HANDLER_H_