CommChannelsManager.h

Go to the documentation of this file.

 
#ifndef VORTEX_COMM_CHANNELS_MANAGER_H_
#define VORTEX_COMM_CHANNELS_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <memory>
 
 
#include "base/BaseSpi.h"
#include "base/BaseI2c.h"
#include "base/BaseUart.h"
#include "base/BaseCan.h"
#include "RtosMutex.h"
 
//==============================================================================
// 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 uart_bus_valid;                
    bool can_bus_valid;                 
    uint8_t spi_device_count;           
    uint8_t i2c_runtime_device_count;   
    CommError last_error;               
};
 
//==============================================================================
// SPI DEVICE IDENTIFIERS
//==============================================================================
 
enum class SpiDeviceId : uint8_t {
    TMC9660_MOTOR_CONTROLLER = 0, 
    AS5047U_POSITION_ENCODER = 1, 
    EXTERNAL_DEVICE_1 = 2,        
    EXTERNAL_DEVICE_2 = 3,        
    DEVICE_COUNT                   
};
 
//==============================================================================
// I2C DEVICE IDENTIFIERS
//==============================================================================
 
enum class I2cDeviceId : uint8_t {
    BNO08X_IMU = 0,             
    PCAL9555_GPIO_EXPANDER = 1, 
    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]] 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 ACCESSORS
    //==========================================================================
 
    BaseI2c* GetI2cDevice(I2cDeviceId device_id) noexcept;
 
    BaseI2c* GetI2cDevice(uint8_t bus_index, int device_index) noexcept;
 
    //==========================================================================
    // RUNTIME I2C DEVICE MANAGEMENT (for ImuManager)
    //==========================================================================
 
    int CreateI2cDevice(uint8_t device_address, uint32_t speed_hz = 400000) noexcept;
 
    bool HasI2cDeviceAtAddress(uint8_t bus_index, uint8_t device_address) const noexcept;
 
    bool RemoveI2cDevice(int device_index) noexcept;
 
    //==========================================================================
    // I2C BUS DIAGNOSTICS — bring-up helpers
    //==========================================================================
 
    [[nodiscard]] bool I2cProbeAddress(uint8_t address, uint32_t timeout_ms = 25) noexcept;
 
    size_t I2cScanBus(uint8_t* out, size_t max_results) noexcept;
 
    bool I2cResetBus() noexcept;
 
    //==========================================================================
    // UART / CAN ACCESSORS
    //==========================================================================
 
    BaseUart* GetUartBus() noexcept;
 
    BaseCan* GetCanBus() noexcept;
 
    BaseCan* GetCanOpenBus() noexcept { return GetCanBus(); }
 
    // The concrete TWAI controller (EspCan, for hf-core's EspTwaiPort) is not handed out here: this
    // header is MCU-free. Platform code gets it from its board binding, e.g. on the ESP32-C6
    // vortex::bsp::esp32c6::CanController() in bsp_bind/esp32c6/VortexBoardBindEsp32c6.h.
 
    uint32_t GetCanBitRate() const noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    void DumpStatistics() const noexcept;
 
private:
    CommChannelsManager() noexcept;
    ~CommChannelsManager();
 
    bool Initialize() noexcept;
 
    void ReleaseLocked() noexcept;
 
    //==========================================================================
    // BUS RESOURCES — created by the board binding (bsp_bind/VortexBoardBind.h),
    // which owns the bus objects in static storage; this manager keeps indices
    // and non-owning pointers.
    //==========================================================================
 
    // SPI bus + device indices
    static constexpr uint8_t kSpiDeviceCount =
        static_cast<uint8_t>(SpiDeviceId::DEVICE_COUNT);
    std::array<int, kSpiDeviceCount> spi_device_indices_{};
    bool spi_bus_valid_{false};
    bool uart_bus_valid_{false};
    bool can_bus_valid_{false};
 
    // I2C bus — built-in devices + bounded runtime slots
    static constexpr uint8_t kI2cBuiltinCount =
        static_cast<uint8_t>(I2cDeviceId::DEVICE_COUNT);
    static constexpr uint8_t kMaxI2cRuntimeDevices = 4;
    std::array<int, kI2cBuiltinCount> i2c_builtin_indices_{};
    bool i2c_bus_valid_{false};
 
    struct RuntimeI2cSlot {
        int device_index{-1};
        uint8_t address{0xFF};
        bool active{false};
    };
    std::array<RuntimeI2cSlot, kMaxI2cRuntimeDevices> i2c_runtime_slots_{};
 
    // UART bus (TMC9660 TMCL) and CAN bus
    BaseUart* uart_bus_{nullptr};
    BaseCan* can_bus_{nullptr};
 
    std::atomic<bool> initialized_{false};
    std::atomic<CommError> last_error_{CommError::SUCCESS};
    mutable RtosMutex mutex_;
 
    void UpdateLastError(CommError error) noexcept {
        last_error_.store(error, std::memory_order_release);
    }
};
 
inline CommChannelsManager& GetCommChannelsManager() noexcept {
    return CommChannelsManager::GetInstance();
}
 
#endif // VORTEX_COMM_CHANNELS_MANAGER_H_