Vortex.h

Go to the documentation of this file.

 
#ifndef VORTEX_API_H_
#define VORTEX_API_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <cstring>
#include <memory>
 
// Forward declarations for all component handlers
class CommChannelsManager;
class NvsManager;
class GpioManager;
class AdcManager;
class MotorController;
class ImuManager;
class EncoderManager;
class LedManager;
class TemperatureManager;
 
// Include the unified Logger
#include "handlers/logger/Logger.h"
#include "RtosMutex.h"
#include "VortexBootReport.h"
#include "VortexDiagnostics.h"
#include "VortexVersion.h"
 
enum class VortexOnboardTmc9660Transport : std::uint8_t {
    Spi = 0,
    Uart = 1,
};
 
//==============================================================================
// VORTEX SYSTEM DIAGNOSTICS
//==============================================================================
 
struct VortexSystemDiagnostics {
    bool system_healthy;                    
    bool nvs_initialized;                   
    bool comms_initialized;                 
    bool gpio_initialized;                  
    bool adc_initialized;                   
    bool motors_initialized;                
    bool imu_initialized;                   
    bool encoders_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 = kVortexManagerCount;  
 
    const char* failed_components_list[kMaxDiagEntries]{};  
    size_t failed_components_list_count{0};                  
    const char* warnings[kMaxDiagEntries]{};                 
    size_t warnings_count{0};                                
    
    VortexSystemDiagnostics() noexcept
        : system_healthy(false), nvs_initialized(false), comms_initialized(false), gpio_initialized(false),
          adc_initialized(false), motors_initialized(false), imu_initialized(false),
          encoders_initialized(false), leds_initialized(false), temp_initialized(false),
          total_components(static_cast<uint32_t>(kVortexManagerCount)), 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 = kVortexManagerCount;
 
    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) {}
};
 
//==============================================================================
// VORTEX API CLASS
//==============================================================================
 
class Vortex {
public:
    //**************************************************************************//
    //**                  SINGLETON ACCESS                                    **//
    //**************************************************************************//
 
    static Vortex& GetInstance() noexcept;
 
    static void SetOnboardTmc9660Transport(VortexOnboardTmc9660Transport transport) noexcept;
 
    [[nodiscard]] static VortexOnboardTmc9660Transport GetOnboardTmc9660Transport() noexcept;
 
    // Non-copyable, non-movable
    Vortex(const Vortex&) = delete;
    Vortex& operator=(const Vortex&) = delete;
    Vortex(Vortex&&) = delete;
    Vortex& operator=(Vortex&&) = delete;
 
    //**************************************************************************//
    //**                  INITIALIZATION METHODS                              **//
    //**************************************************************************//
 
    bool EnsureInitialized() noexcept;
 
    [[nodiscard]] ManagerError GetLastError() const noexcept { return last_error_.load(); }
 
    bool CollectDiagnostics(VortexBoardDiagnostics& out) const noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_; }
 
    bool Shutdown() noexcept;
 
    [[nodiscard]] bool GetSystemDiagnostics(VortexSystemDiagnostics& diagnostics) const noexcept;
 
    [[nodiscard]] std::array<bool, kVortexManagerCount> GetComponentInitializationStatus() const noexcept;
 
    [[nodiscard]] size_t GetFailedComponents(const char* out_names[], size_t max_entries) const noexcept;
 
    [[nodiscard]] size_t GetSystemWarnings(const char* out_warnings[], size_t max_entries) const noexcept;
 
    [[nodiscard]] bool CollectManagerHealth(ManagerHealthSnapshot& snapshot) noexcept;
 
    //**************************************************************************//
    //**                  COMPONENT ACCESS                                    **//
    //**************************************************************************//
 
    CommChannelsManager& comms;
 
    NvsManager& nvs;
 
    GpioManager& gpio;
 
    MotorController& motors;
 
    AdcManager& adc;
 
    ImuManager& imu;
 
    EncoderManager& encoders;
 
    LedManager& leds;
 
    TemperatureManager& temp;
 
    //**************************************************************************//
    //**                  UTILITY METHODS                                     **//
    //**************************************************************************//
 
    [[nodiscard]] uint64_t GetSystemUptimeMs() const noexcept;
 
    [[nodiscard]] uint64_t GetInitializationTimeMs() const noexcept;
 
    void DumpSystemStatistics() const noexcept;
 
    [[nodiscard]] bool PerformHealthCheck() noexcept;
 
    [[nodiscard]] const char* GetSystemVersion() const noexcept;
 
private:
    //**************************************************************************//
    //**                  PRIVATE CONSTRUCTOR                                 **//
    //**************************************************************************//
 
    Vortex() noexcept;
 
    ~Vortex() = default;
 
    //**************************************************************************//
    //**                  PRIVATE INITIALIZATION METHODS                      **//
    //**************************************************************************//
 
    bool InitializeAllComponents() noexcept;
 
    void ShutdownComponentsLocked() noexcept;
 
    void FailClosed(ManagerError why) noexcept;
 
    bool InitializeNvs() noexcept;
 
    bool InitializeComms() noexcept;
 
    bool InitializeGpio() noexcept;
 
    bool InitializeMotors() noexcept;
 
    bool InitializeAdc() noexcept;
 
    bool InitializeImu() noexcept;
 
    bool InitializeEncoders() noexcept;
 
    bool InitializeLeds() noexcept;
 
    bool InitializeTemperature() noexcept;
 
    void UpdateSystemDiagnostics() noexcept;
 
    void AddSystemWarning(const char* warning) noexcept;
 
    //**************************************************************************//
    //**                  PRIVATE MEMBER VARIABLES                            **//
    //**************************************************************************//
 
    std::atomic<bool> initialized_;                    
    std::atomic<uint64_t> initialization_start_time_;  
    std::atomic<uint64_t> initialization_end_time_;    
    
    // Component initialization status
    std::atomic<bool> nvs_initialized_;
    std::atomic<bool> comms_initialized_;
    std::atomic<bool> gpio_initialized_;
    std::atomic<bool> motors_initialized_;
    std::atomic<bool> adc_initialized_;
    std::atomic<bool> imu_initialized_;
    std::atomic<bool> encoders_initialized_;
    std::atomic<bool> leds_initialized_;
    std::atomic<bool> temp_initialized_;
    
    // System diagnostics (fixed-size, no heap allocation)
    mutable VortexSystemDiagnostics diagnostics_;
 
    VortexBootReport report_{};          
    std::atomic<ManagerError> last_error_{ManagerError::None};  
 
    mutable RtosMutex lifecycle_mutex_;
 
    static std::atomic<std::uint8_t> onboard_tmc9660_transport_;
 
    // Component references (these are references to singletons, not owned)
    // NOTE: Removed duplicate _ref_ members - public refs serve both roles
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline Vortex& GetVortex() noexcept {
    return Vortex::GetInstance();
}
 
//==============================================================================
// GLOBAL ACCESS MACROS
//==============================================================================
 
#define VORTEX_API Vortex::GetInstance()
 
#define VORTEX_API_INIT() (Vortex::GetInstance().EnsureInitialized(), Vortex::GetInstance())
 
#endif // VORTEX_API_H_