stm32_adc.hpp

#pragma once
 
#include "main.h"
 
#ifdef HAL_ADC_MODULE_ENABLED
 
#ifdef ADC
#undef ADC
#endif
 
#include "adc.hpp"
#include "libxr.hpp"
 
namespace LibXR
{
 
class STM32ADC
{
  template <typename, typename = void>
  struct GetADCResolution
  {
    float Get(ADC_HandleTypeDef* hadc)
    {
      UNUSED(hadc);
      return 4095.0f;
    }
  };
 
  template <typename T>
  struct GetADCResolution<T, std::void_t<decltype(std::declval<T>().Init.Resolution)>>
  {
    float Get(T* hadc)
    {
      switch (hadc->Init.Resolution)
      {
#ifdef ADC_RESOLUTION_16B
        case ADC_RESOLUTION_16B:
          return 65535.0f;
#endif
#ifdef ADC_RESOLUTION_12B
        case ADC_RESOLUTION_12B:
          return 4095.0f;
#endif
#ifdef ADC_RESOLUTION_10B
        case ADC_RESOLUTION_10B:
          return 1023.0f;
#endif
#ifdef ADC_RESOLUTION_8B
        case ADC_RESOLUTION_8B:
          return 255.0f;
#endif
#ifdef ADC_RESOLUTION_6B
        case ADC_RESOLUTION_6B:
          return 63.0f;
#endif
        default:
          return 4095.0f;
      }
    }
  };
 
 public:
  class Channel : public ADC
  {
   public:
    Channel(STM32ADC* adc, uint8_t index, uint32_t ch);
 
    float Read() override;
 
   private:
    Channel();
    STM32ADC* adc_;
    uint8_t index_;
    uint32_t ch_;
 
    friend class STM32ADC;
  };
 
  STM32ADC(ADC_HandleTypeDef* hadc, RawData dma_buff, const uint32_t* channels,
           uint8_t num_channels, float vref);
 
  ~STM32ADC();
 
  Channel& GetChannel(uint8_t index);
 
  float ReadChannel(uint8_t channel);
 
 private:
  ADC_HandleTypeDef* hadc_;
  const uint8_t NUM_CHANNELS;
  uint8_t filter_size_;
  bool use_dma_;
  RawData dma_buffer_;
  float resolution_;
  Channel* channels_;
  float vref_;
 
  float ConvertToVoltage(float adc_value);
};
 
}  // namespace LibXR
 
#endif