BaseTemperature.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cstdint>
#include <string_view>
 
//--------------------------------------
//  HardFOC Temperature Error Codes (Table)
//--------------------------------------
 
#define HF_TEMP_ERR_LIST(X)                                                                        \
  /* Success codes */                                                                              \
  X(TEMP_SUCCESS, 0, "Success")                                                                    \
  /* General errors */                                                                             \
  X(TEMP_ERR_FAILURE, 1, "General failure")                                                        \
  X(TEMP_ERR_NOT_INITIALIZED, 2, "Not initialized")                                                \
  X(TEMP_ERR_ALREADY_INITIALIZED, 3, "Already initialized")                                        \
  X(TEMP_ERR_INVALID_PARAMETER, 4, "Invalid parameter")                                            \
  X(TEMP_ERR_NULL_POINTER, 5, "Null pointer")                                                      \
  X(TEMP_ERR_OUT_OF_MEMORY, 6, "Out of memory")                                                    \
  /* Sensor specific errors */                                                                     \
  X(TEMP_ERR_SENSOR_NOT_AVAILABLE, 7, "Temperature sensor not available")                          \
  X(TEMP_ERR_SENSOR_BUSY, 8, "Sensor already in use")                                              \
  X(TEMP_ERR_SENSOR_DISABLED, 9, "Sensor is disabled")                                             \
  X(TEMP_ERR_SENSOR_NOT_READY, 10, "Sensor not ready")                                             \
  /* Reading errors */                                                                             \
  X(TEMP_ERR_READ_FAILED, 11, "Failed to read temperature")                                        \
  X(TEMP_ERR_INVALID_READING, 12, "Invalid temperature reading")                                   \
  X(TEMP_ERR_OUT_OF_RANGE, 13, "Temperature out of sensor range")                                  \
  X(TEMP_ERR_TIMEOUT, 14, "Operation timeout")                                                     \
  /* Configuration errors */                                                                       \
  X(TEMP_ERR_INVALID_RANGE, 15, "Invalid temperature range")                                       \
  X(TEMP_ERR_RANGE_TOO_NARROW, 16, "Temperature range too narrow")                                 \
  X(TEMP_ERR_RANGE_TOO_WIDE, 17, "Temperature range too wide")                                     \
  X(TEMP_ERR_UNSUPPORTED_RANGE, 18, "Unsupported temperature range")                               \
  /* Calibration errors */                                                                         \
  X(TEMP_ERR_CALIBRATION_FAILED, 19, "Calibration failed")                                         \
  X(TEMP_ERR_NOT_CALIBRATED, 20, "Sensor not calibrated")                                          \
  X(TEMP_ERR_INVALID_CALIBRATION, 21, "Invalid calibration data")                                  \
  /* Communication errors */                                                                       \
  X(TEMP_ERR_COMMUNICATION_FAILED, 22, "Communication with sensor failed")                         \
  X(TEMP_ERR_CHECKSUM_FAILED, 23, "Data checksum verification failed")                             \
  /* Power management errors */                                                                    \
  X(TEMP_ERR_POWER_DOWN_FAILED, 24, "Failed to power down sensor")                                 \
  X(TEMP_ERR_POWER_UP_FAILED, 25, "Failed to power up sensor")                                     \
  /* Hardware errors */                                                                            \
  X(TEMP_ERR_HARDWARE_FAULT, 26, "Hardware fault detected")                                        \
  X(TEMP_ERR_OVERCURRENT, 27, "Overcurrent condition")                                             \
  X(TEMP_ERR_OVERVOLTAGE, 28, "Overvoltage condition")                                             \
  X(TEMP_ERR_UNDERVOLTAGE, 29, "Undervoltage condition")                                           \
  X(TEMP_ERR_OVERHEATING, 30, "Sensor overheating")                                                \
  /* Resource errors */                                                                            \
  X(TEMP_ERR_RESOURCE_BUSY, 31, "Required resource is busy")                                       \
  X(TEMP_ERR_RESOURCE_UNAVAILABLE, 32, "Required resource unavailable")                            \
  X(TEMP_ERR_INSUFFICIENT_RESOURCES, 33, "Insufficient system resources")                          \
  /* Operation errors */                                                                           \
  X(TEMP_ERR_OPERATION_ABORTED, 34, "Operation was aborted")                                       \
  X(TEMP_ERR_OPERATION_PENDING, 35, "Operation is pending")                                        \
  X(TEMP_ERR_INVALID_STATE, 36, "Invalid sensor state")                                            \
  X(TEMP_ERR_STATE_TRANSITION_FAILED, 37, "State transition failed")                               \
  /* Data processing errors */                                                                     \
  X(TEMP_ERR_DATA_CORRUPTION, 38, "Data corruption detected")                                      \
  X(TEMP_ERR_CONVERSION_FAILED, 39, "Temperature conversion failed")                               \
  X(TEMP_ERR_FILTERING_FAILED, 40, "Temperature filtering failed")                                 \
  /* Threshold and monitoring errors */                                                            \
  X(TEMP_ERR_THRESHOLD_EXCEEDED, 41, "Temperature threshold exceeded")                             \
  X(TEMP_ERR_INVALID_THRESHOLD, 42, "Invalid threshold value")                                     \
  X(TEMP_ERR_MONITORING_FAILED, 43, "Temperature monitoring failed")                               \
  /* Advanced feature errors */                                                                    \
  X(TEMP_ERR_UNSUPPORTED_OPERATION, 44, "Operation not supported")                                 \
  X(TEMP_ERR_DRIVER_ERROR, 45, "Driver error")                                                     \
  X(TEMP_ERR_UNKNOWN, 46, "Unknown error")                                                         \
  /* Maximum error code marker */                                                                  \
  X(TEMP_ERR_MAX, 47, "Maximum error code")
 
//--------------------------------------
//  HardFOC Temperature Error Enum
//--------------------------------------
 
typedef enum {
#define TEMP_ERROR_ENUM(name, code, desc) name = code,
  HF_TEMP_ERR_LIST(TEMP_ERROR_ENUM)
#undef TEMP_ERROR_ENUM
} hf_temp_err_t;
 
//--------------------------------------
//  Error String Utility Implementation
//--------------------------------------
 
constexpr std::string_view HfTempErrToString(hf_temp_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case NAME:                                                                                       \
    return DESC;
    HF_TEMP_ERR_LIST(X)
#undef X
  default:
    return HfTempErrToString(TEMP_ERR_UNKNOWN);
  }
}
 
//--------------------------------------
//  HardFOC Temperature Types
//--------------------------------------
 
typedef enum {
  HF_TEMP_SENSOR_TYPE_UNKNOWN = 0,      
  HF_TEMP_SENSOR_TYPE_INTERNAL,         
  HF_TEMP_SENSOR_TYPE_EXTERNAL_DIGITAL, 
  HF_TEMP_SENSOR_TYPE_EXTERNAL_ANALOG,  
  HF_TEMP_SENSOR_TYPE_THERMOCOUPLE,     
  HF_TEMP_SENSOR_TYPE_RTD,              
  HF_TEMP_SENSOR_TYPE_THERMISTOR,       
  HF_TEMP_SENSOR_TYPE_INFRARED,         
  HF_TEMP_SENSOR_TYPE_MAX               
} hf_temp_sensor_type_t;
 
typedef enum {
  HF_TEMP_STATE_UNINITIALIZED = 0, 
  HF_TEMP_STATE_INITIALIZED,       
  HF_TEMP_STATE_ENABLED,           
  HF_TEMP_STATE_READING,           
  HF_TEMP_STATE_ERROR,             
  HF_TEMP_STATE_DISABLED,          
  HF_TEMP_STATE_CALIBRATING,       
  HF_TEMP_STATE_SLEEPING,          
  HF_TEMP_STATE_MAX                
} hf_temp_state_t;
 
typedef enum {
  HF_TEMP_UNIT_CELSIUS = 0, 
  HF_TEMP_UNIT_FAHRENHEIT,  
  HF_TEMP_UNIT_KELVIN,      
  HF_TEMP_UNIT_RANKINE,     
  HF_TEMP_UNIT_MAX          
} hf_temp_unit_t;
 
typedef enum {
  HF_TEMP_CAP_NONE = 0x00,                 
  HF_TEMP_CAP_THRESHOLD_MONITORING = 0x01, 
  HF_TEMP_CAP_CONTINUOUS_READING = 0x02,   
  HF_TEMP_CAP_CALIBRATION = 0x04,          
  HF_TEMP_CAP_POWER_MANAGEMENT = 0x08,     
  HF_TEMP_CAP_SELF_TEST = 0x10,            
  HF_TEMP_CAP_ALARM_OUTPUT = 0x20,         
  HF_TEMP_CAP_HIGH_PRECISION = 0x40,       
  HF_TEMP_CAP_FAST_RESPONSE = 0x80         
} hf_temp_capabilities_t;
 
//--------------------------------------
//  HardFOC Temperature Configuration
//--------------------------------------
 
typedef struct {
  float range_min_celsius;           
  float range_max_celsius;           
  float resolution;                  
  hf_u32_t sample_rate_hz;           
  bool enable_threshold_monitoring;  
  float high_threshold_celsius;      
  float low_threshold_celsius;       
  bool enable_power_management;      
  bool enable_calibration;           
  hf_u32_t timeout_ms;               
  hf_temp_sensor_type_t sensor_type; 
  hf_u32_t capabilities;             
} hf_temp_config_t;
 
typedef struct {
  float temperature_celsius; 
  float temperature_raw;     
  hf_u64_t timestamp_us;     
  hf_temp_err_t error;       
  bool is_valid;             
  float accuracy_celsius;    
} hf_temp_reading_t;
 
typedef struct {
  hf_temp_sensor_type_t sensor_type; 
  float min_temp_celsius;            
  float max_temp_celsius;            
  float resolution_celsius;          
  float accuracy_celsius;            
  hf_u32_t response_time_ms;         
  hf_u32_t capabilities;             
  const char* manufacturer;          
  const char* model;                 
  const char* version;               
} hf_temp_sensor_info_t;
 
typedef struct {
  hf_u32_t total_operations;          
  hf_u32_t successful_operations;     
  hf_u32_t failed_operations;         
  hf_u32_t temperature_readings;      
  hf_u32_t calibration_count;         
  hf_u32_t threshold_violations;      
  hf_u32_t average_operation_time_us; 
  hf_u32_t max_operation_time_us;     
  hf_u32_t min_operation_time_us;     
  float min_temperature_celsius;      
  float max_temperature_celsius;      
  float avg_temperature_celsius;      
} hf_temp_statistics_t;
 
typedef struct {
  bool sensor_healthy;                 
  hf_temp_err_t last_error_code;       
  hf_u32_t last_error_timestamp;       
  hf_u32_t consecutive_errors;         
  bool sensor_available;               
  bool threshold_monitoring_supported; 
  bool threshold_monitoring_enabled;   
  bool continuous_monitoring_active;   
  hf_u32_t current_temperature_raw;    
  bool calibration_valid;              
} hf_temp_diagnostics_t;
 
//--------------------------------------
//  HardFOC Temperature Callback Types
//--------------------------------------
 
// Forward declaration
class BaseTemperature;
 
using hf_temp_threshold_callback_t =
    void(*)(BaseTemperature* temp_sensor, float temperature_celsius,
            hf_u32_t threshold_type, void* user_data);
 
using hf_temp_reading_callback_t = void(*)(BaseTemperature* temp_sensor, const hf_temp_reading_t* reading, void* user_data);
 
using hf_temp_error_callback_t =
    void(*)(BaseTemperature* temp_sensor, hf_temp_err_t error,
            const char* error_description, void* user_data);
 
//--------------------------------------
//  Utility Functions and Macros
//--------------------------------------
 
#define HF_TEMP_CELSIUS_TO_FAHRENHEIT(celsius) ((celsius) * 9.0f / 5.0f + 32.0f)
 
#define HF_TEMP_FAHRENHEIT_TO_CELSIUS(fahrenheit) (((fahrenheit) - 32.0f) * 5.0f / 9.0f)
 
#define HF_TEMP_CELSIUS_TO_KELVIN(celsius) ((celsius) + 273.15f)
 
#define HF_TEMP_KELVIN_TO_CELSIUS(kelvin) ((kelvin) - 273.15f)
 
#define HF_TEMP_CONFIG_DEFAULT()                                                                   \
  {.range_min_celsius = -40.0f,                                                                    \
   .range_max_celsius = 125.0f,                                                                    \
   .resolution = 0.1f,                                                                             \
   .sample_rate_hz = 0,                                                                            \
   .enable_threshold_monitoring = false,                                                           \
   .high_threshold_celsius = 100.0f,                                                               \
   .low_threshold_celsius = -20.0f,                                                                \
   .enable_power_management = false,                                                               \
   .enable_calibration = false,                                                                    \
   .timeout_ms = 1000,                                                                             \
   .sensor_type = HF_TEMP_SENSOR_TYPE_UNKNOWN,                                                     \
   .capabilities = HF_TEMP_CAP_NONE}
 
inline bool IsTempInRange(float temperature, float min_temp, float max_temp) noexcept {
  return (temperature >= min_temp) && (temperature <= max_temp);
}
//--------------------------------------
//  BaseTemperature Abstract Class
//--------------------------------------
 
class BaseTemperature {
public:
  //==============================================================//
  // CONSTRUCTORS AND DESTRUCTOR
  //==============================================================//
 
  BaseTemperature(const BaseTemperature&) = delete;
 
  BaseTemperature& operator=(const BaseTemperature&) = delete;
 
  virtual ~BaseTemperature() noexcept = default;
 
  //==============================================================//
  // INITIALIZATION AND STATUS
  //==============================================================//
 
  [[nodiscard]] bool IsInitialized() const noexcept;
 
  bool EnsureInitialized() noexcept;
 
  bool EnsureDeinitialized() noexcept;
 
  [[nodiscard]] hf_temp_state_t GetState() const noexcept;
 
protected:
  //==============================================================//
  // [PROTECTED] PURE VIRTUAL IMPLEMENTATIONS - PLATFORM SPECIFIC
  //==============================================================//
 
  virtual bool Initialize() noexcept = 0;
 
  virtual bool Deinitialize() noexcept = 0;
 
  virtual hf_temp_err_t ReadTemperatureCelsiusImpl(float* temperature_celsius) noexcept = 0;
 
public:
  //==============================================================//
  // CORE TEMPERATURE INTERFACE
  //==============================================================//
 
  hf_temp_err_t ReadTemperatureCelsius(float* temperature_celsius) noexcept;
 
  hf_temp_err_t ReadTemperature(hf_temp_reading_t* reading) noexcept;
 
  //==============================================================//
  // TEMPERATURE CONVERSION UTILITIES
  //==============================================================//
 
  hf_temp_err_t ReadTemperatureFahrenheit(float* temperature_fahrenheit) noexcept;
 
  hf_temp_err_t ReadTemperatureKelvin(float* temperature_kelvin) noexcept;
 
  hf_temp_err_t ReadTemperatureUnit(float* temperature, hf_temp_unit_t unit) noexcept;
 
  //==============================================================//
  // INFORMATION INTERFACE
  //==============================================================//
 
  virtual hf_temp_err_t GetSensorInfo(hf_temp_sensor_info_t* info) const noexcept = 0;
 
  [[nodiscard]] virtual hf_u32_t GetCapabilities() const noexcept = 0;
 
  [[nodiscard]] bool HasCapability(hf_temp_capabilities_t capability) const noexcept;
 
  //==============================================================//
  // ADVANCED FEATURES (OPTIONAL - MAY RETURN UNSUPPORTED)
  //==============================================================//
 
  virtual hf_temp_err_t SetRange(float min_celsius, float max_celsius) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetRange(float* min_celsius, float* max_celsius) const noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t SetResolution(float resolution_celsius) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetResolution(float* resolution_celsius) const noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t SetThresholds(float low_threshold_celsius,
                                      float high_threshold_celsius) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetThresholds(float* low_threshold_celsius,
                                      float* high_threshold_celsius) const noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t EnableThresholdMonitoring(hf_temp_threshold_callback_t callback,
                                                  void* user_data) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t DisableThresholdMonitoring() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t StartContinuousMonitoring(hf_u32_t sample_rate_hz,
                                                  hf_temp_reading_callback_t callback,
                                                  void* user_data) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t StopContinuousMonitoring() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  [[nodiscard]] virtual bool IsMonitoringActive() const noexcept {
    return false; // Default: not supported
  }
 
  virtual hf_temp_err_t Calibrate(float reference_temperature_celsius) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t SetCalibrationOffset(float offset_celsius) noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetCalibrationOffset(float* offset_celsius) const noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t ResetCalibration() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t EnterSleepMode() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t ExitSleepMode() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  [[nodiscard]] virtual bool IsSleeping() const noexcept {
    return false; // Default: not supported
  }
 
  virtual hf_temp_err_t SelfTest() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t CheckHealth() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetStatistics(hf_temp_statistics_t& statistics) noexcept {
    statistics = hf_temp_statistics_t{}; // Reset to defaults
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t GetDiagnostics(hf_temp_diagnostics_t& diagnostics) noexcept {
    diagnostics = hf_temp_diagnostics_t{}; // Reset to defaults
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t ResetStatistics() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_temp_err_t ResetDiagnostics() noexcept {
    return hf_temp_err_t::TEMP_ERR_UNSUPPORTED_OPERATION;
  }
 
protected:
  //==============================================================//
  // [PROTECTED] CONSTRUCTOR AND MEMBER VARIABLES
  //==============================================================//
 
  BaseTemperature() noexcept : initialized_(false), current_state_(HF_TEMP_STATE_UNINITIALIZED) {}
 
  hf_temp_err_t ValidateBasicOperation() const noexcept;
 
  //==============================================================//
  // [PROTECTED] MEMBER VARIABLES
  //==============================================================//
 
  bool initialized_;              
  hf_temp_state_t current_state_; 
};
 
//--------------------------------------
//  Inline Implementations
//--------------------------------------
 
inline bool BaseTemperature::IsInitialized() const noexcept {
  return initialized_;
}
 
inline bool BaseTemperature::EnsureInitialized() noexcept {
  if (!initialized_) {
    initialized_ = Initialize();
    if (initialized_) {
      current_state_ = HF_TEMP_STATE_INITIALIZED;
    }
  }
  return initialized_;
}
 
inline bool BaseTemperature::EnsureDeinitialized() noexcept {
  if (initialized_) {
    initialized_ = !Deinitialize();
    if (!initialized_) {
      current_state_ = HF_TEMP_STATE_UNINITIALIZED;
    }
  }
  return !initialized_;
}
 
inline hf_temp_state_t BaseTemperature::GetState() const noexcept {
  return current_state_;
}
 
inline bool BaseTemperature::HasCapability(hf_temp_capabilities_t capability) const noexcept {
  return (GetCapabilities() & capability) != 0;
}
 
inline hf_temp_err_t BaseTemperature::ValidateBasicOperation() const noexcept {
  if (!initialized_) {
    return hf_temp_err_t::TEMP_ERR_NOT_INITIALIZED;
  }
  return hf_temp_err_t::TEMP_SUCCESS;
}
 
inline hf_temp_err_t BaseTemperature::ReadTemperatureCelsius(float* temperature_celsius) noexcept {
  if (temperature_celsius == nullptr) {
    return hf_temp_err_t::TEMP_ERR_NULL_POINTER;
  }
 
  hf_temp_err_t validation = ValidateBasicOperation();
  if (validation != hf_temp_err_t::TEMP_SUCCESS) {
    return validation;
  }
 
  current_state_ = HF_TEMP_STATE_READING;
  hf_temp_err_t result = ReadTemperatureCelsiusImpl(temperature_celsius);
  current_state_ =
      (result == hf_temp_err_t::TEMP_SUCCESS) ? HF_TEMP_STATE_INITIALIZED : HF_TEMP_STATE_ERROR;
 
  return result;
}
 
inline hf_temp_err_t BaseTemperature::ReadTemperature(hf_temp_reading_t* reading) noexcept {
  if (reading == nullptr) {
    return hf_temp_err_t::TEMP_ERR_NULL_POINTER;
  }
 
  // Initialize reading structure
  reading->error = hf_temp_err_t::TEMP_SUCCESS;
  reading->is_valid = false;
  reading->timestamp_us = 0; // Implementation should fill this
  reading->accuracy_celsius = 0.0f;
  reading->temperature_raw = 0.0f;
 
  float temperature;
  hf_temp_err_t error = ReadTemperatureCelsius(&temperature);
 
  reading->temperature_celsius = temperature;
  reading->error = error;
  reading->is_valid = (error == hf_temp_err_t::TEMP_SUCCESS);
 
  return error;
}
 
inline hf_temp_err_t BaseTemperature::ReadTemperatureFahrenheit(
    float* temperature_fahrenheit) noexcept {
  if (temperature_fahrenheit == nullptr) {
    return hf_temp_err_t::TEMP_ERR_NULL_POINTER;
  }
 
  float celsius;
  hf_temp_err_t error = ReadTemperatureCelsius(&celsius);
  if (error == hf_temp_err_t::TEMP_SUCCESS) {
    *temperature_fahrenheit = HF_TEMP_CELSIUS_TO_FAHRENHEIT(celsius);
  }
  return error;
}
 
inline hf_temp_err_t BaseTemperature::ReadTemperatureKelvin(float* temperature_kelvin) noexcept {
  if (temperature_kelvin == nullptr) {
    return hf_temp_err_t::TEMP_ERR_NULL_POINTER;
  }
 
  float celsius;
  hf_temp_err_t error = ReadTemperatureCelsius(&celsius);
  if (error == hf_temp_err_t::TEMP_SUCCESS) {
    *temperature_kelvin = HF_TEMP_CELSIUS_TO_KELVIN(celsius);
  }
  return error;
}
 
inline hf_temp_err_t BaseTemperature::ReadTemperatureUnit(float* temperature,
                                                          hf_temp_unit_t unit) noexcept {
  if (temperature == nullptr) {
    return hf_temp_err_t::TEMP_ERR_NULL_POINTER;
  }
 
  float celsius;
  hf_temp_err_t error = ReadTemperatureCelsius(&celsius);
  if (error == hf_temp_err_t::TEMP_SUCCESS) {
    switch (unit) {
    case HF_TEMP_UNIT_CELSIUS:
      *temperature = celsius;
      break;
    case HF_TEMP_UNIT_FAHRENHEIT:
      *temperature = HF_TEMP_CELSIUS_TO_FAHRENHEIT(celsius);
      break;
    case HF_TEMP_UNIT_KELVIN:
      *temperature = HF_TEMP_CELSIUS_TO_KELVIN(celsius);
      break;
    case HF_TEMP_UNIT_RANKINE:
      *temperature = HF_TEMP_CELSIUS_TO_KELVIN(celsius) * 9.0f / 5.0f;
      break;
    default:
      error = hf_temp_err_t::TEMP_ERR_INVALID_PARAMETER;
      break;
    }
  }
  return error;
}