STM32 ADC 驱动实现 / STM32 ADC driver implementation. More...

#include <stm32_adc.hpp>

Collaboration diagram for LibXR::STM32ADC:

Data Structures
class	Channel
	ADC 通道对象 / ADC channel object. More...

struct	GetADCResolution

struct	GetADCResolution< T, std::void_t< decltype(std::declval< T >().Init.Resolution)> >

struct	HasContinuousConvMode

struct	HasContinuousConvMode< T, std::void_t< decltype(std::declval< T >() ->Init.ContinuousConvMode)> >

struct	HasConversionDataManagement

struct	HasConversionDataManagement< T, std::void_t< decltype(std::declval< T >() ->Init.ConversionDataManagement)> >

struct	HasDMACircularMode

struct	HasDMACircularMode< T, std::void_t< decltype(std::declval< T >() ->DMA_Handle->Init.Mode)> >

struct	HasDMAContinuousRequests

struct	HasDMAContinuousRequests< T, std::void_t< decltype(std::declval< T >() ->Init.DMAContinuousRequests)> >

struct	HasNbrOfConversion

struct	HasNbrOfConversion< T, std::void_t< decltype(std::declval< T >() ->Init.NbrOfConversion)> >

Public Member Functions
	STM32ADC (ADC_HandleTypeDef *hadc, RawData dma_buff, std::initializer_list< uint32_t > channels, float vref)
	构造 ADC 驱动对象 / Construct ADC driver object

	~STM32ADC ()
	析构函数 / Destructor

Channel &	GetChannel (uint8_t index)
	获取 ADC 通道对象 / Get ADC channel object

float	ReadChannel (uint8_t channel)
	读取指定通道电压 / Read channel voltage

Private Member Functions
float	ConvertToVoltage (float adc_value)

Static Private Member Functions
template<typename T >
static std::enable_if< HasContinuousConvMode< T >::value >::type	AssertContinuousConvModeEnabled (T hadc)

template<typename T >
static std::enable_if<!HasContinuousConvMode< T >::value >::type	AssertContinuousConvModeEnabled (T)

template<typename T >
static std::enable_if< HasContinuousConvMode< T >::value >::type	AssertContinuousConvModeDisabled (T hadc)

template<typename T >
static std::enable_if<!HasContinuousConvMode< T >::value >::type	AssertContinuousConvModeDisabled (T)

template<typename T >
static std::enable_if< HasConversionDataManagement< T >::value >::type	AssertDMAContReqEnabled (T hadc)

template<typename T >
static std::enable_if<!HasConversionDataManagement< T >::value &&HasDMAContinuousRequests< T >::value >::type	AssertDMAContReqEnabled (T hadc)

template<typename T >
static std::enable_if<!HasConversionDataManagement< T >::value &&!HasDMAContinuousRequests< T >::value >::type	AssertDMAContReqEnabled (T)

template<typename T >
static std::enable_if< HasNbrOfConversion< T >::value >::type	AssertNbrOfConvEq (T hadc, uint32_t n)

template<typename T >
static std::enable_if<!HasNbrOfConversion< T >::value >::type	AssertNbrOfConvEq (T, uint32_t)

template<typename T >
static std::enable_if< HasDMACircularMode< T >::value >::type	AssertDMACircular (T hadc)

template<typename T >
static std::enable_if<!HasDMACircularMode< T >::value >::type	AssertDMACircular (T)

Private Attributes
std::atomic< uint32_t >	locked_ = 0U

ADC_HandleTypeDef *	hadc_

const uint8_t	NUM_CHANNELS

uint8_t	filter_size_

bool	use_dma_

RawData	dma_buffer_

float	resolution_

Channel **	channels_

float	vref_

Detailed Description

STM32 ADC 驱动实现 / STM32 ADC driver implementation.

Definition at line 22 of file stm32_adc.hpp.

Constructor & Destructor Documentation

◆ STM32ADC()

STM32ADC::STM32ADC	(	ADC_HandleTypeDef *	hadc,
		RawData	dma_buff,
		std::initializer_list< uint32_t >	channels,
		float	vref )

构造 ADC 驱动对象 / Construct ADC driver object

Parameters

hadc	HAL ADC 句柄 / HAL ADC handle
dma_buff	DMA 缓冲区 / DMA buffer
channels	ADC 通道列表 / ADC channel list
vref	参考电压 / Reference voltage

Definition at line 48 of file stm32_adc.cpp.

    : hadc_(hadc),
      NUM_CHANNELS(channels.size()),
      filter_size_(CalculateFilterSize(dma_buff, channels.size())),
      use_dma_(hadc_->DMA_Handle != nullptr),
      dma_buffer_(dma_buff),
      resolution_(GetADCResolution<ADC_HandleTypeDef>{}.Get(hadc)),
      channels_(new Channel*[NUM_CHANNELS]),
      vref_(vref)
{
  auto it = channels.begin();
  for (uint8_t i = 0; i < NUM_CHANNELS; ++i)
  {
    channels_[i] = new Channel(this, i, *it++);
  }
 
#if defined(ADC_CALIB_OFFSET_AND_LINEARITY) && defined(ADC_SINGLE_ENDED)
  HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET_AND_LINEARITY, ADC_SINGLE_ENDED);
#elif defined(ADC_CALIB_OFFSET_LINEARITY) && defined(ADC_SINGLE_ENDED)
  HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED);
#elif defined(ADC_CALIB_OFFSET) && defined(ADC_SINGLE_ENDED)
  HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET, ADC_SINGLE_ENDED);
#elif defined(ADC_SINGLE_ENDED)
  HAL_ADCEx_Calibration_Start(hadc, ADC_SINGLE_ENDED);
#else
  HAL_ADCEx_Calibration_Start(hadc);
#endif
 
  if (use_dma_)
  {
    /* DMA must be in circular mode */
    AssertContinuousConvModeEnabled<H>(hadc_);
    AssertDMAContReqEnabled<H>(hadc_);
    AssertDMACircular<H>(hadc_);
    AssertNbrOfConvEq<H>(hadc_, NUM_CHANNELS);
    HAL_ADC_Start_DMA(hadc_, reinterpret_cast<uint32_t*>(dma_buffer_.addr_),
                      NUM_CHANNELS * filter_size_);
  }
  else
  {
    AssertNbrOfConvEq<H>(hadc_, 1);
    AssertContinuousConvModeDisabled<H>(hadc_);
    HAL_ADC_Start(hadc_);
  }
}

◆ ~STM32ADC()

STM32ADC::~STM32ADC ( )

析构函数 / Destructor

Definition at line 95 of file stm32_adc.cpp.

{
  use_dma_ ? HAL_ADC_Stop_DMA(hadc_) : HAL_ADC_Stop(hadc_);
  for (uint8_t i = 0; i < NUM_CHANNELS; ++i)
  {
    delete channels_[i];
  }
  delete[] channels_;
}

Member Function Documentation

◆ AssertContinuousConvModeDisabled() [1/2]

template<typename T >

static std::enable_if< HasContinuousConvMode< T >::value >::type LibXR::STM32ADC::AssertContinuousConvModeDisabled ( T hadc )

inlinestaticprivate

Definition at line 140 of file stm32_adc.hpp.

  {
    ASSERT(hadc->Init.ContinuousConvMode == DISABLE);
  }

◆ AssertContinuousConvModeDisabled() [2/2]

template<typename T >

static std::enable_if<!HasContinuousConvMode< T >::value >::type LibXR::STM32ADC::AssertContinuousConvModeDisabled ( T )

inlinestaticprivate

Definition at line 147 of file stm32_adc.hpp.

148 {

149 }

◆ AssertContinuousConvModeEnabled() [1/2]

template<typename T >

static std::enable_if< HasContinuousConvMode< T >::value >::type LibXR::STM32ADC::AssertContinuousConvModeEnabled ( T hadc )

inlinestaticprivate

Definition at line 127 of file stm32_adc.hpp.

  {
    ASSERT(hadc->Init.ContinuousConvMode == ENABLE);
  }

◆ AssertContinuousConvModeEnabled() [2/2]

template<typename T >

static std::enable_if<!HasContinuousConvMode< T >::value >::type LibXR::STM32ADC::AssertContinuousConvModeEnabled ( T )

inlinestaticprivate

Definition at line 134 of file stm32_adc.hpp.

135 {

136 }

◆ AssertDMACircular() [1/2]

template<typename T >

static std::enable_if< HasDMACircularMode< T >::value >::type LibXR::STM32ADC::AssertDMACircular ( T hadc )

inlinestaticprivate

Definition at line 194 of file stm32_adc.hpp.

  {
    ASSERT(hadc->DMA_Handle != nullptr);
    ASSERT(hadc->DMA_Handle->Init.Mode == DMA_CIRCULAR);
  }

◆ AssertDMACircular() [2/2]

template<typename T >

static std::enable_if<!HasDMACircularMode< T >::value >::type LibXR::STM32ADC::AssertDMACircular ( T )

inlinestaticprivate

Definition at line 202 of file stm32_adc.hpp.

203 {

204 }

◆ AssertDMAContReqEnabled() [1/3]

template<typename T >

static std::enable_if< HasConversionDataManagement< T >::value >::type LibXR::STM32ADC::AssertDMAContReqEnabled ( T hadc )

inlinestaticprivate

Definition at line 155 of file stm32_adc.hpp.

  {
#ifdef ADC_CONVERSIONDATA_DMA_CIRCULAR
    ASSERT(hadc->Init.ConversionDataManagement == ADC_CONVERSIONDATA_DMA_CIRCULAR);
#else
    UNUSED(hadc);
#endif
  }

◆ AssertDMAContReqEnabled() [2/3]

template<typename T >

static std::enable_if<!HasConversionDataManagement< T >::value &&HasDMAContinuousRequests< T >::value >::type LibXR::STM32ADC::AssertDMAContReqEnabled ( T hadc )

inlinestaticprivate

Definition at line 168 of file stm32_adc.hpp.

  {
    ASSERT(hadc->Init.DMAContinuousRequests == ENABLE);
  }

◆ AssertDMAContReqEnabled() [3/3]

template<typename T >

static std::enable_if<!HasConversionDataManagement< T >::value &&!HasDMAContinuousRequests< T >::value >::type LibXR::STM32ADC::AssertDMAContReqEnabled ( T )

inlinestaticprivate

Definition at line 176 of file stm32_adc.hpp.

177 {

178 }

◆ AssertNbrOfConvEq() [1/2]

template<typename T >

static std::enable_if< HasNbrOfConversion< T >::value >::type LibXR::STM32ADC::AssertNbrOfConvEq	(	T	hadc,
		uint32_t	n )

inlinestaticprivate

Definition at line 181 of file stm32_adc.hpp.

  {
    ASSERT(hadc->Init.NbrOfConversion == n);
  }

◆ AssertNbrOfConvEq() [2/2]

template<typename T >

static std::enable_if<!HasNbrOfConversion< T >::value >::type LibXR::STM32ADC::AssertNbrOfConvEq	(	T	,
		uint32_t	)

inlinestaticprivate

Definition at line 188 of file stm32_adc.hpp.

190 {

191 }

◆ ConvertToVoltage()

float STM32ADC::ConvertToVoltage ( float adc_value )

private

Definition at line 245 of file stm32_adc.cpp.

{
  return adc_value * vref_ / resolution_;
}

◆ GetChannel()

STM32ADC::Channel & STM32ADC::GetChannel ( uint8_t index )

获取 ADC 通道对象 / Get ADC channel object

Parameters

index 通道索引 / Channel index

Returns: Channel& 通道对象引用 / Channel object reference

Definition at line 105 of file stm32_adc.cpp.

105{ return *channels_[index]; }

◆ ReadChannel()

float STM32ADC::ReadChannel ( uint8_t channel )

读取指定通道电压 / Read channel voltage

Parameters

channel 通道号 / Channel number

Returns: float 电压值 / Voltage value

Definition at line 107 of file stm32_adc.cpp.

{
  if (channel >= NUM_CHANNELS)
  {
    ASSERT(false);
    return -1.0f;
  }
 
  uint16_t* buffer = reinterpret_cast<uint16_t*>(dma_buffer_.addr_);
  if (use_dma_)
  {
    STM32_InvalidateDCacheByAddr(buffer, filter_size_ * NUM_CHANNELS * 2);
    uint32_t sum = 0;
    for (uint8_t i = 0; i < filter_size_; ++i)
    {
      sum += buffer[channel + i * NUM_CHANNELS];
    }
    return ConvertToVoltage(static_cast<float>(sum) / static_cast<float>(filter_size_));
  }
 
  ADC_ChannelConfTypeDef config = {};
  uint32_t time = 0;
  UNUSED(time);
#if defined(ADC_SAMPLETIME_16CYCLES)
  time = ADC_SAMPLETIME_16CYCLES;
#elif defined(ADC_SAMPLETIME_16CYCLES_5)
  time = ADC_SAMPLETIME_16CYCLES_5;
#elif defined(ADC_SAMPLETIME_17CYCLES)
  time = ADC_SAMPLETIME_17CYCLES;
#elif defined(ADC_SAMPLETIME_17CYCLES_5)
  time = ADC_SAMPLETIME_17CYCLES_5;
#elif defined(ADC_SAMPLETIME_18CYCLES)
  time = ADC_SAMPLETIME_18CYCLES;
#elif defined(ADC_SAMPLETIME_18CYCLES_5)
  time = ADC_SAMPLETIME_18CYCLES_5;
#elif defined(ADC_SAMPLETIME_19CYCLES)
  time = ADC_SAMPLETIME_19CYCLES;
#elif defined(ADC_SAMPLETIME_19CYCLES_5)
  time = ADC_SAMPLETIME_19CYCLES_5;
#elif defined(ADC_SAMPLETIME_20CYCLES)
  time = ADC_SAMPLETIME_20CYCLES;
#elif defined(ADC_SAMPLETIME_20CYCLES_5)
  time = ADC_SAMPLETIME_20CYCLES_5;
#elif defined(ADC_SAMPLETIME_21CYCLES)
  time = ADC_SAMPLETIME_21CYCLES;
#elif defined(ADC_SAMPLETIME_21CYCLES_5)
  time = ADC_SAMPLETIME_21CYCLES_5;
#elif defined(ADC_SAMPLETIME_22CYCLES)
  time = ADC_SAMPLETIME_22CYCLES;
#elif defined(ADC_SAMPLETIME_22CYCLES_5)
  time = ADC_SAMPLETIME_22CYCLES_5;
#elif defined(ADC_SAMPLETIME_23CYCLES)
  time = ADC_SAMPLETIME_23CYCLES;
#elif defined(ADC_SAMPLETIME_23CYCLES_5)
  time = ADC_SAMPLETIME_23CYCLES_5;
#elif defined(ADC_SAMPLETIME_24CYCLES)
  time = ADC_SAMPLETIME_24CYCLES;
#elif defined(ADC_SAMPLETIME_24CYCLES_5)
  time = ADC_SAMPLETIME_24CYCLES_5;
#elif defined(ADC_SAMPLETIME_25CYCLES)
  time = ADC_SAMPLETIME_25CYCLES;
#elif defined(ADC_SAMPLETIME_25CYCLES_5)
  time = ADC_SAMPLETIME_25CYCLES_5;
#elif defined(ADC_SAMPLETIME_26CYCLES)
  time = ADC_SAMPLETIME_26CYCLES;
#elif defined(ADC_SAMPLETIME_26CYCLES_5)
  time = ADC_SAMPLETIME_26CYCLES_5;
#elif defined(ADC_SAMPLETIME_27CYCLES)
  time = ADC_SAMPLETIME_27CYCLES;
#elif defined(ADC_SAMPLETIME_27CYCLES_5)
  time = ADC_SAMPLETIME_27CYCLES_5;
#elif defined(ADC_SAMPLETIME_28CYCLES)
  time = ADC_SAMPLETIME_28CYCLES;
#elif defined(ADC_SAMPLETIME_28CYCLES_5)
  time = ADC_SAMPLETIME_28CYCLES_5;
#elif defined(ADC_SAMPLETIME_29CYCLES)
  time = ADC_SAMPLETIME_29CYCLES;
#elif defined(ADC_SAMPLETIME_29CYCLES_5)
  time = ADC_SAMPLETIME_29CYCLES_5;
#elif defined(ADC_SAMPLETIME_30CYCLES)
  time = ADC_SAMPLETIME_30CYCLES;
#elif defined(ADC_SAMPLETIME_30CYCLES_5)
  time = ADC_SAMPLETIME_30CYCLES_5;
#elif defined(ADC_SAMPLETIME_31CYCLES)
  time = ADC_SAMPLETIME_31CYCLES;
#elif defined(ADC_SAMPLETIME_31CYCLES_5)
  time = ADC_SAMPLETIME_31CYCLES_5;
#elif defined(ADC_SAMPLETIME_32CYCLES)
  time = ADC_SAMPLETIME_32CYCLES;
#elif defined(ADC_SAMPLETIME_32CYCLES_5)
  time = ADC_SAMPLETIME_32CYCLES_5;
#error "Unsupported sample time"
#endif
 
  config.Channel = channels_[channel]->ch_;
#if defined(ADC_REGULAR_RANK_1)
  config.Rank = ADC_REGULAR_RANK_1;
#else
  config.Rank = 1;
#endif
#if defined(ADC_SINGLE_ENDED) && !defined(STM32L0)
  config.SingleDiff = ADC_SINGLE_ENDED;
#endif
#if defined(ADC_OFFSET_NONE)
  config.OffsetNumber = ADC_OFFSET_NONE;
  config.Offset = 0;
#endif
#if !defined(STM32L0)
  config.SamplingTime = time;
#endif
 
  uint32_t expected = 0U;
 
  if (!locked_.compare_exchange_strong(expected, 0xF0F0F0F0U, std::memory_order_acquire,
                                       std::memory_order_relaxed))
  {
    // Multiple threads are working on the same adc peripheral
    // Please use dma mode
    ASSERT(false);
    return 0.0f;
  }
 
  HAL_ADC_ConfigChannel(hadc_, &config);
 
  uint32_t sum = 0;
  for (uint8_t i = 0; i < filter_size_; ++i)
  {
    HAL_ADC_Start(hadc_);
    HAL_ADC_PollForConversion(hadc_, 20);
    buffer[channel + i * NUM_CHANNELS] = HAL_ADC_GetValue(hadc_);
    sum += buffer[channel + i * NUM_CHANNELS];
  }
 
  locked_.store(0, std::memory_order_release);
 
  return ConvertToVoltage(static_cast<float>(sum) / static_cast<float>(filter_size_));
}

Field Documentation

◆ channels_

Channel** LibXR::STM32ADC::channels_

private

Definition at line 278 of file stm32_adc.hpp.

◆ dma_buffer_

RawData LibXR::STM32ADC::dma_buffer_

private

Definition at line 276 of file stm32_adc.hpp.

◆ filter_size_

uint8_t LibXR::STM32ADC::filter_size_

private

Definition at line 274 of file stm32_adc.hpp.

◆ hadc_

ADC_HandleTypeDef* LibXR::STM32ADC::hadc_

private

Definition at line 272 of file stm32_adc.hpp.

◆ locked_

std::atomic<uint32_t> LibXR::STM32ADC::locked_ = 0U

private

Definition at line 271 of file stm32_adc.hpp.

◆ NUM_CHANNELS

const uint8_t LibXR::STM32ADC::NUM_CHANNELS

private

Definition at line 273 of file stm32_adc.hpp.

◆ resolution_

float LibXR::STM32ADC::resolution_

private

Definition at line 277 of file stm32_adc.hpp.

◆ use_dma_

bool LibXR::STM32ADC::use_dma_

private

Definition at line 275 of file stm32_adc.hpp.

◆ vref_

float LibXR::STM32ADC::vref_

private

Definition at line 279 of file stm32_adc.hpp.

The documentation for this class was generated from the following files:

driver/st/stm32_adc.hpp
driver/st/stm32_adc.cpp

Data Structures

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ STM32ADC()

◆ ~STM32ADC()

Member Function Documentation

◆ AssertContinuousConvModeDisabled() [1/2]

◆ AssertContinuousConvModeDisabled() [2/2]

◆ AssertContinuousConvModeEnabled() [1/2]

◆ AssertContinuousConvModeEnabled() [2/2]

◆ AssertDMACircular() [1/2]

◆ AssertDMACircular() [2/2]

◆ AssertDMAContReqEnabled() [1/3]

◆ AssertDMAContReqEnabled() [2/3]

◆ AssertDMAContReqEnabled() [3/3]

◆ AssertNbrOfConvEq() [1/2]

◆ AssertNbrOfConvEq() [2/2]

◆ ConvertToVoltage()

◆ GetChannel()

◆ ReadChannel()

Field Documentation

◆ channels_

◆ dma_buffer_

◆ filter_size_

◆ hadc_

◆ locked_

◆ NUM_CHANNELS

◆ resolution_

◆ use_dma_

◆ vref_