EncoderManager.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <atomic>
#include <optional>
#include "RtosMutex.h"
#include "handlers/as5047u/As5047uHandler.h"
 
// Forward declarations
class CommChannelsManager;
class GpioManager;
class BaseSpi;
enum class SpiDeviceId : uint8_t;
enum class AS5047U_Error : uint16_t;
 
enum class EncoderError : uint8_t {
    SUCCESS = 0,                
    NOT_INITIALIZED,            
    INITIALIZATION_FAILED,      
    INVALID_PARAMETER,          
    SPI_COMMUNICATION_FAILED,   
    CRC_ERROR,                  
    FRAMING_ERROR,              
    SENSOR_ERROR,               
    TIMEOUT,                    
    MUTEX_LOCK_FAILED           
};
 
using As5047uError = EncoderError;
 
constexpr const char* EncoderErrorToString(EncoderError error) noexcept {
    switch (error) {
        case EncoderError::SUCCESS: return "Success";
        case EncoderError::NOT_INITIALIZED: return "Not initialized";
        case EncoderError::INITIALIZATION_FAILED: return "Initialization failed";
        case EncoderError::INVALID_PARAMETER: return "Invalid parameter";
        case EncoderError::SPI_COMMUNICATION_FAILED: return "SPI communication failed";
        case EncoderError::CRC_ERROR: return "CRC error";
        case EncoderError::FRAMING_ERROR: return "Framing error";
        case EncoderError::SENSOR_ERROR: return "Sensor error";
        case EncoderError::TIMEOUT: return "Timeout";
        case EncoderError::MUTEX_LOCK_FAILED: return "Mutex lock failed";
        default: return "Unknown error";
    }
}
 
constexpr const char* As5047uErrorToString(As5047uError error) noexcept {
    return EncoderErrorToString(error);
}
 
//==============================================================================
// ENCODER DIAGNOSTICS
//==============================================================================
 
struct EncoderFieldStrength {
    uint8_t agc{0};          
    uint16_t magnitude{0};   
};
 
struct EncoderSystemDiagnostics {
    bool system_healthy;               
    bool system_initialized;           
    uint8_t active_device_count;       
    uint8_t initialized_device_count;  
    EncoderError last_error;           
 
    struct DeviceSnapshot {
        bool active;                   
        bool initialized;              
        uint32_t measurement_count;    
        uint32_t communication_error_count; 
    };
    static constexpr uint8_t kMaxDevices = 4;
    DeviceSnapshot devices[kMaxDevices]{}; 
};
 
class EncoderManager {
public:
    static constexpr uint8_t MAX_ENCODER_DEVICES = 4;           
 
    // Slot indices — all user-provisioned, no onboard encoder.
    static constexpr uint8_t ENCODER_SLOT_0 = 0;
    static constexpr uint8_t ENCODER_SLOT_1 = 1;
    static constexpr uint8_t ENCODER_SLOT_2 = 2;
    static constexpr uint8_t ENCODER_SLOT_3 = 3;
 
    static constexpr uint8_t ONBOARD_ENCODER_INDEX = ENCODER_SLOT_0;
 
public:
    static EncoderManager& GetInstance() noexcept;
 
    //**************************************************************************//
    //**                  DEVICE MANAGEMENT METHODS                           **//
    //**************************************************************************//
 
    bool EnsureInitialized() noexcept;
 
    bool IsInitialized() const noexcept;
 
    [[nodiscard]] EncoderError GetLastError() const noexcept { return last_error_.load(std::memory_order_acquire); }
 
    [[nodiscard]] EncoderError GetSystemDiagnostics(EncoderSystemDiagnostics& diagnostics) const noexcept;
 
    bool Deinitialize() noexcept;
 
    //**************************************************************************//
    //**                  HANDLER AND DRIVER MANAGEMENT                       **//
    //**************************************************************************//
 
    As5047uHandler* GetAs5047uHandler(uint8_t deviceIndex = ENCODER_SLOT_0) noexcept;
 
    template <typename Fn>
    bool VisitDriver(uint8_t deviceIndex, Fn&& fn) noexcept {
        MutexLockGuard lock(manager_mutex_);
        As5047uHandler* handler = ReadyHandlerLocked(deviceIndex);
        if (handler == nullptr) {
            return false;
        }
        bool ran = false;
        handler->visitDriver([&](as5047u::AS5047U<As5047uSpiAdapter>& driver) {
            ran = true;
            fn(driver);
        });
        return ran;
    }
 
    //**************************************************************************//
    //**                  DEVICES MANAGEMENT METHODS                           **//
    //**************************************************************************//
 
    bool CreateAs5047uDevice(uint8_t deviceIndex,
                             SpiDeviceId spiDeviceId,
                             const As5047uConfig& config = As5047uHandler::GetDefaultConfig()) noexcept;
 
    bool CreateAs5047uDevice(uint8_t deviceIndex,
                             BaseSpi& spi_interface,
                             const As5047uConfig& config = As5047uHandler::GetDefaultConfig()) noexcept;
 
    bool CreateExternalAs5047uDevice(uint8_t deviceIndex,
                                     SpiDeviceId spiDeviceId,
                                     const As5047uConfig& config = As5047uHandler::GetDefaultConfig()) noexcept {
        return CreateAs5047uDevice(deviceIndex, spiDeviceId, config);
    }
    bool CreateExternalAs5047uDevice(uint8_t deviceIndex,
                                     BaseSpi& spi_interface,
                                     const As5047uConfig& config = As5047uHandler::GetDefaultConfig()) noexcept {
        return CreateAs5047uDevice(deviceIndex, spi_interface, config);
    }
 
    bool DeleteDevice(uint8_t deviceIndex) noexcept;
 
    bool DeleteExternalDevice(uint8_t deviceIndex) noexcept { return DeleteDevice(deviceIndex); }
 
    uint8_t GetDeviceCount() const noexcept;
 
    bool IsDeviceValid(uint8_t deviceIndex) const noexcept;
 
    bool IsExternalSlotAvailable(uint8_t deviceIndex) const noexcept;
 
    void GetActiveDeviceIndices(std::array<uint8_t, MAX_ENCODER_DEVICES>& out, size_t& count) const noexcept;
 
    size_t InitializeAllDevices(std::array<bool, MAX_ENCODER_DEVICES>& results) noexcept;
 
    void GetInitializationStatus(std::array<bool, MAX_ENCODER_DEVICES>& status) const noexcept;
 
    //**************************************************************************//
    //**                  DEVICE INFORMATION METHODS                          **//
    //**************************************************************************//
 
    void GetAvailableDevices(std::array<const char*, MAX_ENCODER_DEVICES>& out, size_t& count) const noexcept;
 
    [[nodiscard]] const char* GetDeviceType(uint8_t deviceIndex) const noexcept;
 
    //**************************************************************************//
    //**                  HIGH-LEVEL ENCODER OPERATIONS                       **//
    //**************************************************************************//
 
    EncoderError ReadAngle(uint8_t deviceIndex, uint16_t& angle) noexcept;
 
    EncoderError ReadAngleDegrees(uint8_t deviceIndex, double& angle_degrees) noexcept;
 
    EncoderError ReadVelocityRPM(uint8_t deviceIndex, double& velocity_rpm) noexcept;
 
    EncoderError ReadDiagnostics(uint8_t deviceIndex, As5047uDiagnostics& diagnostics) noexcept;
 
    EncoderError ReadFieldStrength(uint8_t deviceIndex, EncoderFieldStrength& field) noexcept;
 
    EncoderError SetZeroPosition(uint8_t deviceIndex, uint16_t zero_position) noexcept;
 
    void ReadAllAngles(std::array<uint16_t, MAX_ENCODER_DEVICES>& angles,
                       std::array<uint8_t, MAX_ENCODER_DEVICES>& device_indices,
                       std::array<EncoderError, MAX_ENCODER_DEVICES>& errors,
                       size_t& count) noexcept;
 
    void ReadAllVelocities(std::array<double, MAX_ENCODER_DEVICES>& velocities_rpm,
                           std::array<uint8_t, MAX_ENCODER_DEVICES>& device_indices,
                           std::array<EncoderError, MAX_ENCODER_DEVICES>& errors,
                           size_t& count) noexcept;
 
    bool CheckAllDevicesHealth() noexcept;
 
    //**************************************************************************//
    //**                  SENSOR MONITORING METHODS                           **//
    //**************************************************************************//
 
    uint32_t GetMeasurementCount(uint8_t deviceIndex) const noexcept;
 
    uint32_t GetCommunicationErrorCount(uint8_t deviceIndex) const noexcept;
    
    void DumpStatistics() const noexcept;
 
    // Delete copy/move constructors and assignment operators
    EncoderManager(const EncoderManager&) = delete;
    EncoderManager& operator=(const EncoderManager&) = delete;
    EncoderManager(EncoderManager&&) = delete;
    EncoderManager& operator=(EncoderManager&&) = delete;
 
private:
    EncoderManager() noexcept;
 
    ~EncoderManager() noexcept;
 
    bool Initialize() noexcept;
 
    static bool IsValidDeviceIndex(uint8_t deviceIndex) noexcept {
        return deviceIndex < MAX_ENCODER_DEVICES;
    }
 
    static EncoderError mapDriverError(AS5047U_Error sticky_flags) noexcept;
 
    As5047uHandler* ReadyHandlerLocked(uint8_t deviceIndex) noexcept;
 
    EncoderError FinishRead(uint8_t deviceIndex, AS5047U_Error sticky, bool count_measurement) noexcept;
 
    // ===============================
    // SYSTEM STATE
    // ===============================
 
    std::atomic<bool> initialized_{false};
 
    std::atomic<EncoderError> last_error_{EncoderError::SUCCESS};
 
    mutable RtosMutex manager_mutex_;
 
    // ===============================
    // DEVICE STORAGE
    // ===============================
 
    std::array<std::optional<As5047uHandler>, MAX_ENCODER_DEVICES> as5047u_handlers_;
 
    std::array<bool, MAX_ENCODER_DEVICES> device_initialized_;
 
    std::array<bool, MAX_ENCODER_DEVICES> device_active_;
 
    // (no onboard device — all encoder slots are user-provisioned)
 
    // ===============================
    // DEPENDENCIES
    // ===============================
 
    CommChannelsManager* comm_manager_ = nullptr;
 
    GpioManager* gpio_manager_ = nullptr;
 
    // ===============================
    // SENSOR MONITORING
    // ===============================
 
    std::array<std::atomic<uint32_t>, MAX_ENCODER_DEVICES> measurement_counts_{0};  
    std::array<std::atomic<uint32_t>, MAX_ENCODER_DEVICES> communication_error_counts_{0};  
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline EncoderManager& GetEncoderManager() noexcept {
    return EncoderManager::GetInstance();
}