CommChannelsManager.h

Go to the documentation of this file.

 
#ifndef FLUX_COMM_CHANNELS_MANAGER_H_
#define FLUX_COMM_CHANNELS_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
 
// Forward declaration — only appears as the return type of GetI2cBus()
class BaseI2c;
 
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseSpi.h"
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseCan.h"
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseUart.h"
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseUsbSerialJtag.h"
#include "RtosMutex.h"
#include "flux_hal/flux_hal_types.hpp"
 
//==============================================================================
// COMM CHANNELS ERROR CODES
//==============================================================================
 
enum class CommError : uint8_t {
    SUCCESS = 0,              
    NOT_INITIALIZED,          
    INITIALIZATION_FAILED,    
    BUS_NOT_AVAILABLE,        
    DEVICE_NOT_FOUND,         
    INVALID_BUS_INDEX,        
    INVALID_DEVICE_INDEX,     
    DEVICE_ALREADY_EXISTS,    
    DEVICE_CREATION_FAILED,   
    COMMUNICATION_FAILED,     
    INVALID_PARAMETER,        
    MUTEX_LOCK_FAILED         
};
 
constexpr const char* CommErrorToString(CommError error) noexcept {
    switch (error) {
        case CommError::SUCCESS:                return "Success";
        case CommError::NOT_INITIALIZED:        return "Not initialized";
        case CommError::INITIALIZATION_FAILED:  return "Initialization failed";
        case CommError::BUS_NOT_AVAILABLE:      return "Bus not available";
        case CommError::DEVICE_NOT_FOUND:       return "Device not found";
        case CommError::INVALID_BUS_INDEX:      return "Invalid bus index";
        case CommError::INVALID_DEVICE_INDEX:   return "Invalid device index";
        case CommError::DEVICE_ALREADY_EXISTS:  return "Device already exists";
        case CommError::DEVICE_CREATION_FAILED: return "Device creation failed";
        case CommError::COMMUNICATION_FAILED:   return "Communication failed";
        case CommError::INVALID_PARAMETER:      return "Invalid parameter";
        case CommError::MUTEX_LOCK_FAILED:      return "Mutex lock failed";
        default:                                return "Unknown error";
    }
}
 
//==============================================================================
// COMM CHANNELS DIAGNOSTICS
//==============================================================================
 
struct CommSystemDiagnostics {
    bool system_healthy;            
    bool system_initialized;        
    bool spi_bus_valid;             
    bool i2c_bus_valid;             
    bool can_bus_valid;             
    uint8_t spi_device_count;       
    CommError last_error;           
};
 
//==============================================================================
// SPI DEVICE IDENTIFIERS
//==============================================================================
 
enum class SpiDeviceId : uint8_t {
    MAX22200_SOLENOID_DRIVER = 0,   
    TLE92466_LOWSIDE_DRIVER = 1,    
    ADS7952_ADC_0 = 2,              
    DEVICE_COUNT                     
};
 
//==============================================================================
// COMM CHANNELS MANAGER
//==============================================================================
 
class CommChannelsManager {
public:
    static CommChannelsManager& GetInstance() noexcept;
 
    // Non-copyable, non-movable
    CommChannelsManager(const CommChannelsManager&) = delete;
    CommChannelsManager& operator=(const CommChannelsManager&) = delete;
    CommChannelsManager(CommChannelsManager&&) = delete;
    CommChannelsManager& operator=(CommChannelsManager&&) = delete;
 
    //==========================================================================
    // INITIALIZATION
    //==========================================================================
 
    bool EnsureInitialized() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    [[nodiscard]] CommError GetLastError() const noexcept { return last_error_.load(std::memory_order_acquire); }
 
    [[nodiscard]] flux::hal::ManagerError GetManagerError() const noexcept {
        return manager_error_.load(std::memory_order_acquire);
    }
 
    [[nodiscard]] bool IsPressureBusReady() const noexcept { return spi3_bus_valid_; }
 
    [[nodiscard]] bool IsCanReady() const noexcept { return can_bus_valid_; }
 
    [[nodiscard]] CommError GetSystemDiagnostics(CommSystemDiagnostics& diagnostics) const noexcept;
 
    bool Deinitialize() noexcept;
 
    //==========================================================================
    // SPI ACCESSORS
    //==========================================================================
 
    BaseSpi* GetSpiDevice(SpiDeviceId device_id) noexcept;
 
    BaseSpi* GetSpiDevice(uint8_t device_index) noexcept;
 
    //==========================================================================
    // I2C — not present on Flux V1
    //==========================================================================
 
    BaseI2c* GetI2cBus() noexcept { return nullptr; }
 
    //==========================================================================
    // CAN ACCESSOR
    //==========================================================================
 
    BaseCan* GetCanBus() noexcept;
 
    //==========================================================================
    // UART ACCESSORS
    //==========================================================================
 
    struct UartAcquireConfig {
        uint8_t  port_number;       
        int16_t  tx_pin;            
        int16_t  rx_pin;            
        int16_t  rts_pin;           
        int16_t  cts_pin;           
        uint32_t baud_bps;
        uint16_t tx_buffer_size;
        uint16_t rx_buffer_size;
    };
 
    static constexpr uint8_t kMaxUartPorts = 3;
 
    BaseUart* AcquireUart(const UartAcquireConfig& cfg) noexcept;
 
    BaseUart* GetUart(uint8_t port_number) noexcept;
 
    //==========================================================================
    // USB SERIAL/JTAG ACCESSORS (ESP32-S3/-C3/-C6 native USB-VCP + JTAG)
    //==========================================================================
 
    BaseUsbSerialJtag* AcquireUsbSerialJtag(
        const hf_usb_serial_jtag_config_t& cfg = {}) noexcept;
 
    BaseUsbSerialJtag* GetUsbSerialJtag() noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    void DumpStatistics() const noexcept;
 
private:
    CommChannelsManager() noexcept = default;
    ~CommChannelsManager() = default;
 
    bool Initialize() noexcept;
    void ReleaseLocked() noexcept;
 
    //==========================================================================
    // HARDWARE RESOURCES — objects live in the platform binding (bsp_bind);
    //                      the manager holds Base* pointers only
    //==========================================================================
 
    static constexpr uint8_t kSpiDeviceCount = static_cast<uint8_t>(SpiDeviceId::DEVICE_COUNT);
 
    bool spi_bus_valid_{false};    
    bool spi3_bus_valid_{false};   
 
    std::array<BaseSpi*, kSpiDeviceCount> spi_devices_{};
 
    BaseCan* can_bus_{nullptr};    
    bool can_bus_valid_{false};
 
    // Lazy UART pool — one slot per hardware UART port. App-driven:
    // sensors (BASIS-2, FDO2, etc.) call `AcquireUart(cfg)` at boot.
    std::array<BaseUart*, kMaxUartPorts> uarts_{};
 
    // Lazy USB Serial/JTAG. The controller is a single silicon block, owned by
    // the platform binding; we only cache the resolved pointer here.
    BaseUsbSerialJtag* usb_serial_jtag_{nullptr};
 
    std::atomic<bool> initialized_{false};
    std::atomic<CommError> last_error_{CommError::SUCCESS};
    std::atomic<flux::hal::ManagerError> manager_error_{flux::hal::ManagerError::NotInitialized};
    mutable RtosMutex mutex_;
 
    void UpdateLastError(CommError error) noexcept {
        last_error_.store(error, std::memory_order_release);
    }
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline CommChannelsManager& GetCommChannelsManager() noexcept {
    return CommChannelsManager::GetInstance();
}
 
#endif // FLUX_COMM_CHANNELS_MANAGER_H_