TLE92466ED.hpp

Go to the documentation of this file.

 
#ifndef TLE92466ED_HPP
#define TLE92466ED_HPP
 
#include "TLE92466ED_HAL.hpp"
#include "TLE92466ED_Registers.hpp"
#include <expected>
#include <array>
 
namespace TLE92466ED {
 
enum class DriverError : uint8_t {
    None = 0,             
    NotInitialized,       
    HardwareError,        
    InvalidChannel,       
    InvalidParameter,     
    DeviceNotResponding,  
    WrongDeviceID,        
    RegisterError,        
    CRCError,             
    FaultDetected,        
    ConfigurationError,   
    TimeoutError,         
    WrongMode,            
    SPIFrameError,        
    WriteToReadOnly       
};
 
template<typename T>
using DriverResult = std::expected<T, DriverError>;
 
struct ChannelConfig {
    ChannelMode mode{ChannelMode::ICC};              
    uint16_t current_setpoint_ma{0};                 
    SlewRate slew_rate{SlewRate::MEDIUM_2V5_US};     
    DiagCurrent diag_current{DiagCurrent::I_80UA};   
    uint8_t open_load_threshold{3};                  
    uint16_t pwm_period_mantissa{0};                 
    uint8_t pwm_period_exponent{0};                  
    bool auto_limit_disabled{false};                 
    bool olsg_warning_enabled{false};                
    bool deep_dither_enabled{false};                 
    uint16_t dither_step_size{0};                    
    uint8_t dither_steps{0};                         
    uint8_t dither_flat{0};                          
};
 
struct DeviceStatus {
    bool config_mode{true};            
    bool init_done{false};             
    bool any_fault{false};             
    
    // Supply voltage faults
    bool vbat_uv{false};               
    bool vbat_ov{false};               
    bool vio_uv{false};                
    bool vio_ov{false};                
    bool vdd_uv{false};                
    bool vdd_ov{false};                
    
    // Temperature
    bool ot_warning{false};            
    bool ot_error{false};              
    
    // Other faults
    bool clock_fault{false};           
    bool spi_wd_error{false};          
    bool por_event{false};             
    bool reset_event{false};           
    
    // Internal diagnostics
    bool supply_nok_internal{false};   
    bool supply_nok_external{false};   
    
    // Voltage readings
    uint16_t vbat_voltage{0};          
    uint16_t vio_voltage{0};           
};
 
struct ChannelDiagnostics {
    // Error flags
    bool overcurrent{false};           
    bool short_to_ground{false};       
    bool open_load{false};             
    bool over_temperature{false};      
    bool open_load_short_ground{false};
    
    // Warning flags
    bool ot_warning{false};            
    bool current_regulation_warning{false}; 
    bool pwm_regulation_warning{false};
    bool olsg_warning{false};          
    
    // Measurements
    uint16_t average_current{0};       
    uint16_t duty_cycle{0};            
    uint16_t min_current{0};           
    uint16_t max_current{0};           
    uint16_t vbat_feedback{0};         
};
 
struct GlobalConfig {
    bool crc_enabled{true};            
    bool spi_watchdog_enabled{true};   
    bool clock_watchdog_enabled{true}; 
    bool vio_5v{false};                
    uint8_t vbat_uv_threshold{25};     
    uint8_t vbat_ov_threshold{255};    
    uint16_t spi_watchdog_reload{1000};
};
 
class Driver {
public:
    explicit Driver(HAL& hal) noexcept : hal_(hal), initialized_(false), mission_mode_(false) {}
 
    ~Driver() noexcept {
        if (initialized_) {
            // Best effort shutdown - ignore errors
            (void)disable_all_channels();
        }
    }
 
    // Prevent copying
    Driver(const Driver&) = delete;
    Driver& operator=(const Driver&) = delete;
 
    // Delete move operations (contains reference member)
    Driver(Driver&&) noexcept = delete;
    Driver& operator=(Driver&&) noexcept = delete;
 
    //==========================================================================
    // INITIALIZATION AND MODE CONTROL
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> init() noexcept;
 
    [[nodiscard]] DriverResult<void> enter_mission_mode() noexcept;
 
    [[nodiscard]] DriverResult<void> enter_config_mode() noexcept;
 
    [[nodiscard]] bool is_mission_mode() const noexcept {
        return mission_mode_;
    }
 
    //==========================================================================
    // GLOBAL CONFIGURATION
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> configure_global(const GlobalConfig& config) noexcept;
 
    [[nodiscard]] DriverResult<void> set_crc_enabled(bool enabled) noexcept;
 
    [[nodiscard]] DriverResult<void> set_vbat_thresholds(uint8_t uv_threshold, uint8_t ov_threshold) noexcept;
 
    //==========================================================================
    // CHANNEL CONTROL
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> enable_channel(Channel channel, bool enabled) noexcept;
 
    [[nodiscard]] DriverResult<void> enable_channels(uint8_t channel_mask) noexcept;
 
    [[nodiscard]] DriverResult<void> enable_all_channels() noexcept;
 
    [[nodiscard]] DriverResult<void> disable_all_channels() noexcept;
 
    [[nodiscard]] DriverResult<void> set_channel_mode(Channel channel, ChannelMode mode) noexcept;
 
    [[nodiscard]] DriverResult<void> set_parallel_operation(ParallelPair pair, bool enabled) noexcept;
 
    //==========================================================================
    // CURRENT CONTROL (ICC MODE)
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> set_current_setpoint(
        Channel channel, 
        uint16_t current_ma,
        bool parallel_mode = false) noexcept;
 
    [[nodiscard]] DriverResult<uint16_t> get_current_setpoint(
        Channel channel,
        bool parallel_mode = false) noexcept;
 
    [[nodiscard]] DriverResult<void> configure_pwm_period(
        Channel channel,
        uint8_t period_mantissa,
        uint8_t period_exponent,
        bool low_freq_range = false) noexcept;
 
    [[nodiscard]] DriverResult<void> configure_dither(
        Channel channel,
        uint16_t step_size,
        uint8_t num_steps,
        uint8_t flat_steps) noexcept;
 
    [[nodiscard]] DriverResult<void> configure_channel(
        Channel channel,
        const ChannelConfig& config) noexcept;
 
    //==========================================================================
    // STATUS AND DIAGNOSTICS
    //==========================================================================
 
    [[nodiscard]] DriverResult<DeviceStatus> get_device_status() noexcept;
 
    [[nodiscard]] DriverResult<ChannelDiagnostics> get_channel_diagnostics(Channel channel) noexcept;
 
    [[nodiscard]] DriverResult<uint16_t> get_average_current(
        Channel channel,
        bool parallel_mode = false) noexcept;
 
    [[nodiscard]] DriverResult<uint16_t> get_duty_cycle(Channel channel) noexcept;
 
    [[nodiscard]] DriverResult<uint16_t> get_vbat_voltage() noexcept;
 
    [[nodiscard]] DriverResult<uint16_t> get_vio_voltage() noexcept;
 
    //==========================================================================
    // FAULT MANAGEMENT
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> clear_faults() noexcept;
 
    [[nodiscard]] DriverResult<bool> has_any_fault() noexcept;
 
    [[nodiscard]] DriverResult<void> software_reset() noexcept;
 
    //==========================================================================
    // WATCHDOG MANAGEMENT
    //==========================================================================
 
    [[nodiscard]] DriverResult<void> reload_spi_watchdog(uint16_t reload_value) noexcept;
 
    //==========================================================================
    // DEVICE INFORMATION
    //==========================================================================
 
    [[nodiscard]] DriverResult<uint16_t> get_ic_version() noexcept;
 
    [[nodiscard]] DriverResult<std::array<uint16_t, 3>> get_chip_id() noexcept;
 
    [[nodiscard]] DriverResult<bool> verify_device() noexcept;
 
    [[nodiscard]] bool is_initialized() const noexcept {
        return initialized_;
    }
 
    //==========================================================================
    // REGISTER ACCESS (Advanced)
    //==========================================================================
 
    [[nodiscard]] DriverResult<uint16_t> read_register(
        uint16_t address,
        bool verify_crc = true) noexcept;
 
    [[nodiscard]] DriverResult<void> write_register(
        uint16_t address,
        uint16_t value,
        bool verify_crc = true) noexcept;
 
    [[nodiscard]] DriverResult<void> modify_register(
        uint16_t address,
        uint16_t mask,
        uint16_t value) noexcept;
 
private:
    //==========================================================================
    // PRIVATE METHODS
    //==========================================================================
 
    [[nodiscard]] DriverResult<SPIFrame> transfer_frame(const SPIFrame& tx_frame, bool verify_crc = true) noexcept;
 
    [[nodiscard]] constexpr bool is_valid_channel_internal(Channel channel) const noexcept {
        return is_valid_channel(channel);
    }
 
    [[nodiscard]] DriverResult<void> check_initialized() const noexcept {
        if (!initialized_) {
            return std::unexpected(DriverError::NotInitialized);
        }
        return {};
    }
 
    [[nodiscard]] DriverResult<void> check_mission_mode() const noexcept {
        if (!mission_mode_) {
            return std::unexpected(DriverError::WrongMode);
        }
        return {};
    }
 
    [[nodiscard]] DriverResult<void> check_config_mode() const noexcept {
        if (mission_mode_) {
            return std::unexpected(DriverError::WrongMode);
        }
        return {};
    }
 
    [[nodiscard]] DriverResult<void> apply_default_config() noexcept;
 
    [[nodiscard]] DriverResult<void> check_spi_status(const SPIFrame& rx_frame) noexcept;
 
    [[nodiscard]] DriverResult<bool> is_channel_parallel(Channel channel) noexcept;
 
    //==========================================================================
    // MEMBER VARIABLES
    //==========================================================================
 
    HAL& hal_;                              
    bool initialized_;                      
    bool mission_mode_;                     
    uint16_t channel_enable_cache_;         
    std::array<uint16_t, 6> channel_setpoints_; 
};
 
} // namespace TLE92466ED
 
#endif // TLE92466ED_HPP