Flux.h

Go to the documentation of this file.

 
#ifndef FLUX_API_H_
#define FLUX_API_H_
 
#include <array>
#include <atomic>
#include <cstddef>
#include <cstring>
 
#include "FluxVersion.h"
#include "flux_hal/flux_hal_types.hpp"
#include "handlers/logger/Logger.h"
 
// Forward declarations
class CommChannelsManager;
class NvsManager;
class GpioManager;
class ValveManager;
class AdcManager;
class LedManager;
class TemperatureManager;
 
inline constexpr size_t kFluxManagerCount = 7;
 
//==============================================================================
// FLUX SYSTEM DIAGNOSTICS
//==============================================================================
 
struct FluxSystemDiagnostics {
    bool system_healthy;           
    bool nvs_initialized;           
    bool comms_initialized;        
    bool gpio_initialized;         
    bool valves_initialized;       
    bool adc_initialized;          
    bool leds_initialized;         
    bool temp_initialized;         
 
    uint32_t total_components;         
    uint32_t initialized_components;   
    uint32_t failed_components;        
 
    uint64_t initialization_time_ms;   
    uint64_t system_uptime_ms;         
 
    static constexpr size_t kMaxDiagEntries = kFluxManagerCount;  
    const char* failed_components_list[kMaxDiagEntries]{}; 
    size_t failed_components_list_count{0};                
 
    FluxSystemDiagnostics() noexcept
        : system_healthy(false), nvs_initialized(false), comms_initialized(false), gpio_initialized(false),
          valves_initialized(false), adc_initialized(false), leds_initialized(false),
          temp_initialized(false), total_components(static_cast<uint32_t>(kFluxManagerCount)),
          initialized_components(0),
          failed_components(0), initialization_time_ms(0), system_uptime_ms(0) {}
};
 
//==============================================================================
// MANAGER HEALTH SNAPSHOT
//==============================================================================
 
struct ManagerHealthEntry {
    const char* name;           
    bool initialized;           
    bool has_error;             
    uint8_t last_error_code;    
 
    ManagerHealthEntry() noexcept
        : name(nullptr), initialized(false), has_error(false), last_error_code(0) {}
};
 
struct ManagerHealthSnapshot {
    static constexpr size_t kMaxManagers = kFluxManagerCount;
 
    ManagerHealthEntry entries[kMaxManagers];    
    size_t count;                                
    size_t managers_with_errors;                 
    bool all_healthy;                            
 
    ManagerHealthSnapshot() noexcept
        : entries{}, count(0), managers_with_errors(0), all_healthy(true) {}
};
 
//==============================================================================
// AGGREGATED DIAGNOSTICS (shared ManagerError catalog)
//==============================================================================
 
struct ManagerDiagnostic {
    const char* name{nullptr};                                     
    bool required{false};                                          
    bool initialized{false};                                       
    flux::hal::ManagerError error{flux::hal::ManagerError::NotInitialized};  
};
 
struct FluxHalDiagnostics {
    bool initialized{false};       
    bool all_managers_up{false};   
    bool all_healthy{false};       
    flux::hal::ManagerError first_error{flux::hal::ManagerError::None};  
    const char* first_error_manager{nullptr};                      
 
    std::array<ManagerDiagnostic, kFluxManagerCount> managers{};   
 
    bool max22200_ready{false};      
    bool tle92466_ready{false};      
    bool pressure_bus_ready{false};  
    bool ads7952_ready{false};       
    bool internal_adc_ready{false};  
    bool can_ready{false};           
    bool die_temp_ready{false};      
    bool ntc_ready{false};           
    bool mcp9700_ready{false};       
    bool status_led_ready{false};    
};
 
//==============================================================================
// FLUX API CLASS
//==============================================================================
 
class Flux {
public:
    //==========================================================================
    // SINGLETON ACCESS
    //==========================================================================
 
    static Flux& GetInstance() noexcept;
 
    Flux(const Flux&) = delete;
    Flux& operator=(const Flux&) = delete;
    Flux(Flux&&) = delete;
    Flux& operator=(Flux&&) = delete;
 
    //==========================================================================
    // INITIALIZATION
    //==========================================================================
 
    bool EnsureInitialized() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_; }
 
    bool Shutdown() noexcept;
 
    [[nodiscard]] bool GetSystemDiagnostics(FluxSystemDiagnostics& diagnostics) const noexcept;
 
    [[nodiscard]] std::array<bool, kFluxManagerCount> GetComponentInitializationStatus() const noexcept;
 
    [[nodiscard]] size_t GetFailedComponents(const char* out[], size_t max_count) const noexcept;
 
    [[nodiscard]] size_t GetSystemWarnings(const char* out[], size_t max_count) const noexcept;
 
    [[nodiscard]] bool CollectManagerHealth(ManagerHealthSnapshot& snapshot) noexcept;
 
    bool CollectDiagnostics(FluxHalDiagnostics& out) const noexcept;
 
    [[nodiscard]] flux::hal::ManagerError GetLastError() const noexcept {
        return last_error_.load(std::memory_order_acquire);
    }
 
    //==========================================================================
    // COMPONENT ACCESS (public references to singletons)
    //==========================================================================
 
    CommChannelsManager& comms;     
    NvsManager&          nvs;       
    GpioManager&         gpio;      
    ValveManager&        valves;    
    AdcManager&          adc;       
    LedManager&          leds;      
    TemperatureManager&  temp;      
 
    //==========================================================================
    // UTILITY
    //==========================================================================
 
    [[nodiscard]] uint64_t GetSystemUptimeMs() const noexcept;
 
    [[nodiscard]] uint64_t GetInitializationTimeMs() const noexcept;
 
    //==========================================================================
    // SYSTEM CONTROL (MCU-agnostic wrappers)
    //==========================================================================
 
    [[nodiscard]] uint32_t GetLastResetReason() const noexcept;
 
    [[nodiscard]] uint32_t GetFreeHeapBytes() const noexcept;
 
    [[nodiscard]] uint32_t GetLargestFreeHeapBlock() const noexcept;
 
    [[noreturn]] void SystemRestart() const noexcept;
 
    void DumpSystemStatistics() const noexcept;
 
    [[nodiscard]] bool PerformHealthCheck() noexcept;
 
    [[nodiscard]] const char* GetSystemVersion() const noexcept;
 
private:
    Flux() noexcept;
    ~Flux() = default;
 
    bool InitializeAllComponents() noexcept;
    bool InitializeNvs() noexcept;
    bool InitializeComms() noexcept;
    bool InitializeGpio() noexcept;
    bool InitializeValves() noexcept;
    bool InitializeAdc() noexcept;
    bool InitializeLeds() noexcept;
    bool InitializeTemperature() noexcept;
    void UpdateSystemDiagnostics() noexcept;
 
    //==========================================================================
    // STATE
    //==========================================================================
 
    std::atomic<bool> initialized_{false};
    std::atomic<flux::hal::ManagerError> last_error_{flux::hal::ManagerError::None};
    std::atomic<uint64_t> initialization_start_time_{0};
    std::atomic<uint64_t> initialization_end_time_{0};
 
    std::atomic<bool> nvs_initialized_{false};
    std::atomic<bool> comms_initialized_{false};
    std::atomic<bool> gpio_initialized_{false};
    std::atomic<bool> valves_initialized_{false};
    std::atomic<bool> adc_initialized_{false};
    std::atomic<bool> leds_initialized_{false};
    std::atomic<bool> temp_initialized_{false};
 
    mutable FluxSystemDiagnostics diagnostics_;
 
    static constexpr size_t kMaxFailedComponents = kFluxManagerCount;
    const char* failed_components_[kMaxFailedComponents]{};
    size_t failed_components_count_{0};
 
    static constexpr size_t kMaxSystemWarnings = 16;
    const char* system_warnings_[kMaxSystemWarnings]{};
    size_t system_warnings_count_{0};
 
    void AddSystemWarning(const char* warning) noexcept {
        if (system_warnings_count_ < kMaxSystemWarnings) {
            system_warnings_[system_warnings_count_++] = warning;
        }
    }
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline Flux& GetFlux() noexcept {
    return Flux::GetInstance();
}
 
//==============================================================================
// GLOBAL ACCESS MACROS
//==============================================================================
 
#define FLUX_API       Flux::GetInstance()
#define FLUX_API_INIT() (Flux::GetInstance().EnsureInitialized(), Flux::GetInstance())
 
#endif // FLUX_API_H_