libxr
Embedded C++ framework for bare-metal, RTOS and Linux
Loading...
Searching...
No Matches
stm32_adc.cpp
1#include "stm32_adc.hpp"
2
3#include <cstddef>
4#include <limits>
5
6#include "libxr_def.hpp"
7#include "stm32_dcache.hpp"
8
9#ifdef HAL_ADC_MODULE_ENABLED
10
11using namespace LibXR;
12
13using H = ADC_HandleTypeDef*;
14
15#if defined(HAL_ADC_MODULE_ENABLED) && !defined(ADC_CALIB_OFFSET_AND_LINEARITY) && \
16 !defined(ADC_CALIB_OFFSET_LINEARITY) && !defined(ADC_CALIB_OFFSET) && \
17 !defined(ADC_SINGLE_ENDED)
18extern "C" HAL_StatusTypeDef
19 __attribute__((weak)) HAL_ADCEx_Calibration_Start(ADC_HandleTypeDef* hadc)
20{
21 (void)hadc;
22 return HAL_OK;
23}
24#endif
25
26namespace
27{
28
29uint8_t CalculateFilterSize(RawData dma_buff, std::size_t channel_count)
30{
31 ASSERT(channel_count > 0U);
32
33 const std::size_t filter_size = dma_buff.size_ / channel_count / sizeof(uint16_t);
34 ASSERT(filter_size > 0U);
35 ASSERT(filter_size <= std::numeric_limits<uint8_t>::max());
36 return static_cast<uint8_t>(filter_size);
37}
38
39} // namespace
40
41STM32ADC::Channel::Channel(STM32ADC* adc, uint8_t index, uint32_t ch)
42 : adc_(adc), index_(index), ch_(ch)
43{
44}
45
46float STM32ADC::Channel::Read() { return adc_->ReadChannel(index_); }
47
48STM32ADC::STM32ADC(ADC_HandleTypeDef* hadc, RawData dma_buff,
49 std::initializer_list<uint32_t> channels, float vref)
50 : hadc_(hadc),
51 NUM_CHANNELS(channels.size()),
52 filter_size_(CalculateFilterSize(dma_buff, channels.size())),
53 use_dma_(hadc_->DMA_Handle != nullptr),
54 dma_buffer_(dma_buff),
55 resolution_(GetADCResolution<ADC_HandleTypeDef>{}.Get(hadc)),
56 channels_(new Channel*[NUM_CHANNELS]),
57 vref_(vref)
58{
59 auto it = channels.begin();
60 for (uint8_t i = 0; i < NUM_CHANNELS; ++i)
61 {
62 channels_[i] = new Channel(this, i, *it++);
63 }
64
65#if defined(ADC_CALIB_OFFSET_AND_LINEARITY) && defined(ADC_SINGLE_ENDED)
66 HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET_AND_LINEARITY, ADC_SINGLE_ENDED);
67#elif defined(ADC_CALIB_OFFSET_LINEARITY) && defined(ADC_SINGLE_ENDED)
68 HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED);
69#elif defined(ADC_CALIB_OFFSET) && defined(ADC_SINGLE_ENDED)
70 HAL_ADCEx_Calibration_Start(hadc, ADC_CALIB_OFFSET, ADC_SINGLE_ENDED);
71#elif defined(ADC_SINGLE_ENDED)
72 HAL_ADCEx_Calibration_Start(hadc, ADC_SINGLE_ENDED);
73#else
74 HAL_ADCEx_Calibration_Start(hadc);
75#endif
76
77 if (use_dma_)
78 {
79 /* DMA must be in circular mode */
80 AssertContinuousConvModeEnabled<H>(hadc_);
81 AssertDMAContReqEnabled<H>(hadc_);
82#if !defined(LIBXR_STM32_ADC_GPDMA)
83 AssertDMACircular<H>(hadc_);
84#endif
85 AssertNbrOfConvEq<H>(hadc_, NUM_CHANNELS);
86#if defined(LIBXR_STM32_ADC_GPDMA)
87 [[maybe_unused]] const auto adc_dma_result =
88 gpdma_adapter_.Start(hadc_, reinterpret_cast<uint32_t*>(dma_buffer_.addr_),
89 NUM_CHANNELS * filter_size_, dma_buffer_.size_);
90 REQUIRE(adc_dma_result == HAL_OK);
91#else
92 HAL_ADC_Start_DMA(hadc_, reinterpret_cast<uint32_t*>(dma_buffer_.addr_),
93 NUM_CHANNELS * filter_size_);
94#endif
95 }
96 else
97 {
98 AssertNbrOfConvEq<H>(hadc_, 1);
99 AssertContinuousConvModeDisabled<H>(hadc_);
100 HAL_ADC_Start(hadc_);
101 }
102}
103
104STM32ADC::~STM32ADC()
105{
106#if defined(LIBXR_STM32_ADC_GPDMA)
107 if (use_dma_)
108 {
109 [[maybe_unused]] const auto adc_dma_result = gpdma_adapter_.Stop(hadc_);
110 REQUIRE(adc_dma_result == HAL_OK);
111 }
112 else
113 {
114 HAL_ADC_Stop(hadc_);
115 }
116#else
117 use_dma_ ? HAL_ADC_Stop_DMA(hadc_) : HAL_ADC_Stop(hadc_);
118#endif
119 for (uint8_t i = 0; i < NUM_CHANNELS; ++i)
120 {
121 delete channels_[i];
122 }
123 delete[] channels_;
124}
125
126STM32ADC::Channel& STM32ADC::GetChannel(uint8_t index) { return *channels_[index]; }
127
128float STM32ADC::ReadChannel(uint8_t channel)
129{
130 ASSERT(channel < NUM_CHANNELS);
131
132 uint16_t* buffer = reinterpret_cast<uint16_t*>(dma_buffer_.addr_);
133 if (use_dma_)
134 {
135 STM32_InvalidateDCacheByAddr(buffer, filter_size_ * NUM_CHANNELS * 2);
136 uint32_t sum = 0;
137 for (uint8_t i = 0; i < filter_size_; ++i)
138 {
139 sum += buffer[channel + i * NUM_CHANNELS];
140 }
141 return ConvertToVoltage(static_cast<float>(sum) / static_cast<float>(filter_size_));
142 }
143
144 ADC_ChannelConfTypeDef config = {};
145 uint32_t time = 0;
146 UNUSED(time);
147#if defined(ADC_SAMPLETIME_16CYCLES)
148 time = ADC_SAMPLETIME_16CYCLES;
149#elif defined(ADC_SAMPLETIME_16CYCLES_5)
150 time = ADC_SAMPLETIME_16CYCLES_5;
151#elif defined(ADC_SAMPLETIME_17CYCLES)
152 time = ADC_SAMPLETIME_17CYCLES;
153#elif defined(ADC_SAMPLETIME_17CYCLES_5)
154 time = ADC_SAMPLETIME_17CYCLES_5;
155#elif defined(ADC_SAMPLETIME_18CYCLES)
156 time = ADC_SAMPLETIME_18CYCLES;
157#elif defined(ADC_SAMPLETIME_18CYCLES_5)
158 time = ADC_SAMPLETIME_18CYCLES_5;
159#elif defined(ADC_SAMPLETIME_19CYCLES)
160 time = ADC_SAMPLETIME_19CYCLES;
161#elif defined(ADC_SAMPLETIME_19CYCLES_5)
162 time = ADC_SAMPLETIME_19CYCLES_5;
163#elif defined(ADC_SAMPLETIME_20CYCLES)
164 time = ADC_SAMPLETIME_20CYCLES;
165#elif defined(ADC_SAMPLETIME_20CYCLES_5)
166 time = ADC_SAMPLETIME_20CYCLES_5;
167#elif defined(ADC_SAMPLETIME_21CYCLES)
168 time = ADC_SAMPLETIME_21CYCLES;
169#elif defined(ADC_SAMPLETIME_21CYCLES_5)
170 time = ADC_SAMPLETIME_21CYCLES_5;
171#elif defined(ADC_SAMPLETIME_22CYCLES)
172 time = ADC_SAMPLETIME_22CYCLES;
173#elif defined(ADC_SAMPLETIME_22CYCLES_5)
174 time = ADC_SAMPLETIME_22CYCLES_5;
175#elif defined(ADC_SAMPLETIME_23CYCLES)
176 time = ADC_SAMPLETIME_23CYCLES;
177#elif defined(ADC_SAMPLETIME_23CYCLES_5)
178 time = ADC_SAMPLETIME_23CYCLES_5;
179#elif defined(ADC_SAMPLETIME_24CYCLES)
180 time = ADC_SAMPLETIME_24CYCLES;
181#elif defined(ADC_SAMPLETIME_24CYCLES_5)
182 time = ADC_SAMPLETIME_24CYCLES_5;
183#elif defined(ADC_SAMPLETIME_25CYCLES)
184 time = ADC_SAMPLETIME_25CYCLES;
185#elif defined(ADC_SAMPLETIME_25CYCLES_5)
186 time = ADC_SAMPLETIME_25CYCLES_5;
187#elif defined(ADC_SAMPLETIME_26CYCLES)
188 time = ADC_SAMPLETIME_26CYCLES;
189#elif defined(ADC_SAMPLETIME_26CYCLES_5)
190 time = ADC_SAMPLETIME_26CYCLES_5;
191#elif defined(ADC_SAMPLETIME_27CYCLES)
192 time = ADC_SAMPLETIME_27CYCLES;
193#elif defined(ADC_SAMPLETIME_27CYCLES_5)
194 time = ADC_SAMPLETIME_27CYCLES_5;
195#elif defined(ADC_SAMPLETIME_28CYCLES)
196 time = ADC_SAMPLETIME_28CYCLES;
197#elif defined(ADC_SAMPLETIME_28CYCLES_5)
198 time = ADC_SAMPLETIME_28CYCLES_5;
199#elif defined(ADC_SAMPLETIME_29CYCLES)
200 time = ADC_SAMPLETIME_29CYCLES;
201#elif defined(ADC_SAMPLETIME_29CYCLES_5)
202 time = ADC_SAMPLETIME_29CYCLES_5;
203#elif defined(ADC_SAMPLETIME_30CYCLES)
204 time = ADC_SAMPLETIME_30CYCLES;
205#elif defined(ADC_SAMPLETIME_30CYCLES_5)
206 time = ADC_SAMPLETIME_30CYCLES_5;
207#elif defined(ADC_SAMPLETIME_31CYCLES)
208 time = ADC_SAMPLETIME_31CYCLES;
209#elif defined(ADC_SAMPLETIME_31CYCLES_5)
210 time = ADC_SAMPLETIME_31CYCLES_5;
211#elif defined(ADC_SAMPLETIME_32CYCLES)
212 time = ADC_SAMPLETIME_32CYCLES;
213#elif defined(ADC_SAMPLETIME_32CYCLES_5)
214 time = ADC_SAMPLETIME_32CYCLES_5;
215#error "Unsupported sample time"
216#endif
217
218 config.Channel = channels_[channel]->ch_;
219#if defined(ADC_REGULAR_RANK_1)
220 config.Rank = ADC_REGULAR_RANK_1;
221#else
222 config.Rank = 1;
223#endif
224#if defined(ADC_SINGLE_ENDED) && !defined(STM32L0)
225 config.SingleDiff = ADC_SINGLE_ENDED;
226#endif
227#if defined(ADC_OFFSET_NONE)
228 config.OffsetNumber = ADC_OFFSET_NONE;
229 config.Offset = 0;
230#endif
231#if !defined(STM32L0)
232 config.SamplingTime = time;
233#endif
234
235 uint32_t expected = 0U;
236
237 // Multiple threads are working on the same adc peripheral
238 // Please use dma mode
239 const bool locked = locked_.compare_exchange_strong(
240 expected, 0xF0F0F0F0U, std::memory_order_acquire, std::memory_order_relaxed);
241 REQUIRE(locked);
242
243 HAL_ADC_ConfigChannel(hadc_, &config);
244
245 uint32_t sum = 0;
246 for (uint8_t i = 0; i < filter_size_; ++i)
247 {
248 HAL_ADC_Start(hadc_);
249 HAL_ADC_PollForConversion(hadc_, 20);
250 buffer[channel + i * NUM_CHANNELS] = HAL_ADC_GetValue(hadc_);
251 sum += buffer[channel + i * NUM_CHANNELS];
252 }
253
254 locked_.store(0, std::memory_order_release);
255
256 return ConvertToVoltage(static_cast<float>(sum) / static_cast<float>(filter_size_));
257}
258
259float STM32ADC::ConvertToVoltage(float adc_value)
260{
261 return adc_value * vref_ / resolution_;
262}
263
264#endif
LibXR::RawData
可写原始数据视图 / Mutable raw data view
Definition libxr_type.hpp:54
LibXR::RawData::size_
size_t size_
数据字节数 / Data size in bytes
Definition libxr_type.hpp:155
LibXR::RawData::addr_
void * addr_
数据起始地址 / Data start address
Definition libxr_type.hpp:154
LibXR::STM32ADC::Channel
ADC 通道对象 / ADC channel object.
Definition stm32_adc.hpp:217
LibXR::STM32ADC::Channel::Read
float Read() override
读取 ADC 电压值 / Read ADC voltage
Definition stm32_adc.cpp:46
LibXR::STM32ADC
STM32 ADC 驱动实现 / STM32 ADC driver implementation.
Definition stm32_adc.hpp:25
LibXR::STM32ADC::STM32ADC
STM32ADC(ADC_HandleTypeDef *hadc, RawData dma_buff, std::initializer_list< uint32_t > channels, float vref)
构造 ADC 驱动对象 / Construct ADC driver object
Definition stm32_adc.cpp:48
LibXR::STM32ADC::~STM32ADC
~STM32ADC()
析构函数 / Destructor
Definition stm32_adc.cpp:104
LibXR::STM32ADC::ReadChannel
float ReadChannel(uint8_t channel)
读取指定通道电压 / Read channel voltage
Definition stm32_adc.cpp:128
LibXR::STM32ADC::GetChannel
Channel & GetChannel(uint8_t index)
获取 ADC 通道对象 / Get ADC channel object
Definition stm32_adc.cpp:126
LibXR
LibXR 命名空间 / LibXR namespace.
Definition ch32_can.hpp:14
LibXR::STM32_InvalidateDCacheByAddr
void STM32_InvalidateDCacheByAddr(const void *addr, size_t size)
失效指定内存范围覆盖的 D-Cache cache line Invalidates D-Cache lines covering the specified memory range
Definition stm32_dcache.hpp:72