TemperatureManager.h

Go to the documentation of this file.

 
#ifndef FLUX_TEMPERATURE_MANAGER_H_
#define FLUX_TEMPERATURE_MANAGER_H_
 
#include <array>
#include <atomic>
#include <cstdint>
#include <optional>
#include <string_view>
 
#include "core/hf-core-drivers/internal/hf-internal-interface-wrap/inc/base/BaseTemperature.h"
#include "handlers/mcp9700/Mcp9700TemperatureHandler.h"
#include "handlers/ntc/NtcTemperatureHandler.h"
#include "handlers/logger/Logger.h"
#include "RtosMutex.h"
#include "flux_hal/flux_hal_types.hpp"
 
//==============================================================================
// TEMPERATURE ERROR CODES
//==============================================================================
 
enum class TemperatureError : uint8_t {
    SUCCESS = 0,              
    NOT_INITIALIZED,          
    INITIALIZATION_FAILED,    
    SENSOR_NOT_FOUND,         
    SENSOR_NOT_AVAILABLE,     
    READ_FAILED,              
    INVALID_PARAMETER,        
    NO_SENSORS_AVAILABLE,     
    ALLOCATION_FAILED,        
    DEPENDENCY_NOT_READY,     
    MUTEX_LOCK_FAILED         
};
 
constexpr const char* TemperatureErrorToString(TemperatureError error) noexcept {
    switch (error) {
        case TemperatureError::SUCCESS:               return "Success";
        case TemperatureError::NOT_INITIALIZED:       return "Not initialized";
        case TemperatureError::INITIALIZATION_FAILED: return "Initialization failed";
        case TemperatureError::SENSOR_NOT_FOUND:      return "Sensor not found";
        case TemperatureError::SENSOR_NOT_AVAILABLE:  return "Sensor not available";
        case TemperatureError::READ_FAILED:           return "Read failed";
        case TemperatureError::INVALID_PARAMETER:     return "Invalid parameter";
        case TemperatureError::NO_SENSORS_AVAILABLE:  return "No sensors available";
        case TemperatureError::ALLOCATION_FAILED:     return "Allocation failed";
        case TemperatureError::DEPENDENCY_NOT_READY:  return "Dependency not ready";
        case TemperatureError::MUTEX_LOCK_FAILED:     return "Mutex lock failed";
        default:                                      return "Unknown error";
    }
}
 
//==============================================================================
// SENSOR TYPE ENUM
//==============================================================================
 
enum class FluxTempSensorType : uint8_t {
    ESP32_INTERNAL = 0, 
    NTC_THERMISTOR = 1, 
    MCP9700_THERMISTOR = 2, 
    SENSOR_COUNT        
};
 
constexpr const char* FluxTempSensorTypeToString(FluxTempSensorType type) noexcept {
    switch (type) {
        case FluxTempSensorType::ESP32_INTERNAL: return "ESP32 Internal";
        case FluxTempSensorType::NTC_THERMISTOR: return "NTC Thermistor";
        case FluxTempSensorType::MCP9700_THERMISTOR: return "MCP9700 Thermistor";
        default: return "Unknown";
    }
}
 
//==============================================================================
// TEMPERATURE ENTRY — stack-allocated metadata (drivers owned via unique_ptr)
//==============================================================================
 
struct TempEntry {
    std::string_view name;                   
    FluxTempSensorType sensor_type{FluxTempSensorType::SENSOR_COUNT}; 
    bool registered{false};                  
    float last_reading_celsius{0.0f};        
 
    // Statistics
    uint32_t read_count{0};                  
    uint32_t error_count{0};                 
};
 
//==============================================================================
// TEMPERATURE DIAGNOSTICS
//==============================================================================
 
struct TempSystemDiagnostics {
    bool system_healthy;                    
    uint32_t total_sensors_registered;      
    uint32_t sensors_by_type[8];            
    uint32_t total_operations;              
    uint32_t successful_operations;         
    uint32_t failed_operations;             
    uint32_t communication_errors;          
    uint32_t hardware_errors;               
    uint64_t system_uptime_ms;              
    TemperatureError last_error;            
    float system_min_temp_celsius;          
    float system_max_temp_celsius;          
    float system_avg_temp_celsius;          
};
 
//==============================================================================
// TEMPERATURE MANAGER
//==============================================================================
 
class TemperatureManager {
public:
    //==========================================================================
    // SINGLETON AND LIFECYCLE
    //==========================================================================
 
    static TemperatureManager& GetInstance() noexcept;
 
    TemperatureManager(const TemperatureManager&) = delete;
    TemperatureManager& operator=(const TemperatureManager&) = delete;
    TemperatureManager(TemperatureManager&&) = delete;
    TemperatureManager& operator=(TemperatureManager&&) = delete;
 
    [[nodiscard]] bool EnsureInitialized() noexcept;
 
    [[nodiscard]] bool IsInitialized() const noexcept { return initialized_.load(std::memory_order_acquire); }
 
    [[nodiscard]] bool Deinitialize() noexcept;
 
    [[nodiscard]] TemperatureError 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 IsSensorReady(FluxTempSensorType type) const noexcept;
 
    [[nodiscard]] bool IsDegraded() const noexcept {
        return IsInitialized() && GetManagerError() != flux::hal::ManagerError::None;
    }
 
    //==========================================================================
    // TEMPERATURE READING
    //==========================================================================
 
    [[nodiscard]] TemperatureError ReadTemperatureCelsius(std::string_view name, float& temperature_c) noexcept;
 
    [[nodiscard]] TemperatureError ReadTemperatureFahrenheit(std::string_view name, float& temperature_f) noexcept;
 
    [[nodiscard]] TemperatureError ReadInternalTemperature(float& temperature_c) noexcept;
 
    [[nodiscard]] TemperatureError ReadNtcTemperature(float& temperature_c) noexcept;
 
    [[nodiscard]] TemperatureError ReadMcp9700Temperature(float& temperature_c) noexcept;
 
    [[nodiscard]] TemperatureError GetSystemTemperatureStats(float& min_c, float& max_c, float& avg_c) noexcept;
 
    //==========================================================================
    // SENSOR INFO
    //==========================================================================
 
    [[nodiscard]] size_t GetSensorCount() const noexcept { return registered_count_; }
 
    [[nodiscard]] const TempEntry* GetSensorEntry(std::string_view name) const noexcept;
 
    //==========================================================================
    // DIAGNOSTICS
    //==========================================================================
 
    [[nodiscard]] TemperatureError GetSystemDiagnostics(TempSystemDiagnostics& diag) const noexcept;
 
    void DumpStatistics() const noexcept;
 
private:
    TemperatureManager() noexcept = default;
    ~TemperatureManager() = default;
 
    bool Initialize() noexcept;
    void ReleaseLocked() noexcept;
    bool InitializeEsp32Internal() noexcept;
    bool InitializeNtcThermistor() noexcept;
    bool InitializeMcp9700Thermistor() noexcept;
 
    [[nodiscard]] size_t FindByName(std::string_view name) const noexcept;
 
    //==========================================================================
    // STORAGE
    //==========================================================================
 
    static constexpr size_t kMaxSensors = static_cast<size_t>(FluxTempSensorType::SENSOR_COUNT);
    static constexpr size_t kInvalidIndex = SIZE_MAX;
 
    std::array<TempEntry, kMaxSensors> entries_{};
    size_t registered_count_{0};
    uint64_t init_time_ms_{0};  
 
    // Sensor driver instances. The MCU die sensor is owned by the platform binding;
    // the two thermistor handlers are members, constructed in place at bring-up (no heap).
    BaseTemperature* die_temp_{nullptr};
    std::optional<NtcTemperatureHandler> ntc_handler_;
    std::optional<Mcp9700TemperatureHandler> mcp9700_handler_;
 
    std::atomic<bool> initialized_{false};
    std::atomic<TemperatureError> last_error_{TemperatureError::SUCCESS};
    std::atomic<flux::hal::ManagerError> manager_error_{flux::hal::ManagerError::NotInitialized};
    mutable RtosMutex mutex_;
};
 
//==============================================================================
// CONVENIENCE
//==============================================================================
 
[[nodiscard]] inline TemperatureManager& GetTemperatureManager() noexcept {
    return TemperatureManager::GetInstance();
}
 
#endif // FLUX_TEMPERATURE_MANAGER_H_