说明：驱动基于STm32G031K6测试，其他型号需自行做改动。
! `4 o$ t( V( u* j. i7 V3 I
ADC的初始化：

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   " b  G1 k) X0 V! C) V: F
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   
3. uint8_t STM32LLADC1Init(void)
   
4. {
   + \! p9 ?, B$ s) M( f
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   6 L( z' T* t0 Q: @/ _7 Y. ^
7. 
   1 j* n$ a+ N' A8 Q2 u* d
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   " K5 b/ {! }/ P2 s
9. 
     a- P) f! k0 w: P* B
10.   /* Peripheral clock enable */
    
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    % t( U. P# P6 @- [
12. 
    6 T, P. j/ {9 W4 R9 ^
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    + @  m# m% c2 u+ o/ y4 K2 l+ }
14.   /**ADC1 GPIO Configuration  
    0 T, G$ v7 X* d' {: ^1 Z, y1 H
15.   PA5   ------> ADC1_IN5
    & ?+ @( L9 d, K) Z) m  i  a# J) D
16.   PA7   ------> ADC1_IN7
    
17.   */
    + K: |& P& v" k9 N4 U* a' x5 e( c! j
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    7 L8 o* D' E8 C; a$ M9 p3 C
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    1 s; t$ B6 K% }" u* s( O1 i0 A
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
22. 
    
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    - e# k4 K2 H; |: H) r1 B  r
27. 
    - T3 m' t5 Q) ~6 C: W3 |( I
28. 
    ! s) b) [- y* H2 ~) Z0 @5 _
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    
30.   */
    ) U7 l: }8 K1 r5 P, h; |4 n
31.   ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;                //ADC定时转化触发条件来源，可以为软件触发或硬件（外部中断、定时器）触发。
    7 O$ W+ e6 E+ b; h% R
32.   ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS;     //ADC顺序采集通道的个数，根据自己需要的通道个数设置
    
33.   ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;       //
    
34.   ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;                 //采集方式，单次采集还是连续采集
    * ?9 p* ~' u7 V5 H9 [$ F
35.   ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED;         //使能DMA，并使用无限传输，如果DMA保存方式为循环覆盖的话才可以使用无限传输。
    7 \5 z6 m/ C- I8 {4 w0 J
36.   ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_OVERWRITTEN;               //采集的数据循环覆盖模式
    
37.   LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
    
38.   LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE);                      //失能过采样
    + R, w3 n5 {( K% f, I
39.   LL_ADC_SetTriggerFrequencyMode(ADC1, LL_ADC_CLOCK_FREQ_MODE_HIGH);          //采样时钟使用高频模式
    
40.   LL_ADC_REG_SetSequencerConfigurable(ADC1, LL_ADC_REG_SEQ_CONFIGURABLE);     //adc通道和硬件adc in是否强制对应，因为adc的io使用时不是连续的，所以这里使用可自定义配置
    
41.   LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_COMMON_1,     LL_ADC_SAMPLINGTIME_160CYCLES_5);    //设置通道共用取样时间，根据需要自行选择
    7 i) }/ e5 M" Y3 D$ O) w) t- R
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    & {, N; p* J8 ]6 ^# A
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    8 d6 }' G( A. u, V# X# H
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    ; W, X0 `) s& a* h9 ~
45.   ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;         //采样分辨率
    
46.   ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;    //采样数据对齐方式，右对齐高位补0，左对齐低位补0.
    
47.   ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE;        //低功耗模式，使用DMA的话无法使用，这里关闭
    
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    : ?- r  ]( U; u
49.   /** Configure Regular Channel
    0 G2 Z7 N/ r' `. [3 q+ B
50.   */
    ; h1 w  a: H. ~8 I; A
51.   //ADC_RegularChannelConfig
    % @5 u) m- z3 P& B
52.   LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_1, ADCIO1_IN_CHANNEL);                //将硬件通道ADCIO1_IN_CHANNEL映射到ADC通道1
    
53.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO1_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1); //设置通道采样时间
    
54.   LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, ADCIO2_IN_CHANNEL);                //将硬件通道ADCIO1_IN_CHANNEL映射到ADC通道2
    
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
    % J2 k6 a4 ~8 u. S: U
56. 
    
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    
58.   //LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_VREFINT);
    
59.   //LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_VREFINT, LL_ADC_SAMPLINGTIME_COMMON_1);
    
60. return 1;
    
61. }

复制代码

激活并校准ADC：
6 V- x! {* e( O$ [% F- j# F

1. uint8_t STM32ActivateADC1(void)
   / O( a8 t9 @) T2 G0 D# b2 M2 x) M
2. {
   
3.   __IO uint32_t wait_loop_index = 0U;
   
4.   __IO uint32_t backup_setting_adc_dma_transfer = 0U;
   
5.   uint32_t Timeout = 0U; /* Variable used for timeout management */
   
6.   /*## Operation on ADC hierarchical scope: ADC instance #####################*/
   $ H5 C( L3 r* U; }9 O. Y( v7 C
7. 
   3 O5 S- z! t0 i8 n5 n2 C  i
8.   /* Note: Hardware constraint (refer to description of the functions         */
   / M4 g( R' \; C0 A; V* s) d
9.   /*       below):                                                            */
   
10.   /*       On this STM32 serie, setting of these features is conditioned to   */
    
11.   /*       ADC state:                                                         */
    
12.   /*       ADC must be disabled.                                              */
    
13.   /* Note: In this example, all these checks are not necessary but are        */
    
14.   /*       implemented anyway to show the best practice usages                */
    ' e& H7 r/ E( j  d
15.   /*       corresponding to reference manual procedure.                       */
    5 d; V3 T/ i4 I
16.   /*       Software can be optimized by removing some of these checks, if     */
    
17.   /*       they are not relevant considering previous settings and actions    */
    5 r. ]+ `0 }$ G2 z" z/ s
18.   /*       in user application.                                               */
    ' ~: y! ~8 I- k' j
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    
20.   {
    
21.     /* Enable ADC internal voltage regulator */
    4 s4 v; F1 v2 H; P# K
22.     LL_ADC_EnableInternalRegulator(ADC1);
    1 l/ P- D, S; C6 I% j* y
23. 
    2 q8 ]* ~) `4 S' q
24.     /* Delay for ADC internal voltage regulator stabilization.                */
    ! O& Z- h/ C2 ?
25.     /* Compute number of CPU cycles to wait for, from delay in us.            */
    ( C; }! v+ j! H+ v
26.     /* Note: Variable divided by 2 to compensate partially                    */
      S2 O1 I- {' n1 E5 i/ \2 x' q( N7 v  c
27.     /*       CPU processing cycles (depends on compilation optimization).     */
    ' q5 c5 P& c- B7 d  _
28.     /* Note: If system core clock frequency is below 200kHz, wait time        */
    
29.     /*       is only a few CPU processing cycles.                             */
      v" j( m% B  B0 `4 y
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    
31.     while(wait_loop_index != 0)
    
32.     {
    
33.       wait_loop_index--;
    8 q) |4 K! \- ~+ s, f4 y1 T' G( D. _
34.     }
    
35. 
    : J  b; v6 S8 {( J
36.     /* Disable ADC DMA transfer request during calibration */
    
37.     /* Note: Specificity of this STM32 serie: Calibration factor is           */
    
38.     /*       available in data register and also transfered by DMA.           */
    
39.     /*       To not insert ADC calibration factor among ADC conversion data   */
    5 V3 i  j7 j- @4 e1 k3 i- D
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    ( S6 U) C+ f0 @; W& u4 G9 Q7 W
41.     /*       calibration.                                                     */
    0 \1 J2 j8 I9 `
42.     backup_setting_adc_dma_transfer = LL_ADC_REG_GetDMATransfer(ADC1);
    
43.     LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
    
44. 
    - h# b- [( s! m$ x- r! c
45.     /* Run ADC self calibration */
    
46.     LL_ADC_StartCalibration(ADC1);
    * S8 W7 |$ y! G/ \9 g. c/ c" Q  m6 @5 C
47. 
    
48.     /* Poll for ADC effectively calibrated */
    
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    2 [/ f3 t  Z1 E' K9 c* a
50. 
    * X0 W+ S4 ]2 g4 }9 m$ {. S0 [& i8 ?
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    8 e" V4 \, {$ h4 r; O- J, h; E
52.     {
    
53.       /* Check Systick counter flag to decrement the time-out value */
    
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    
56.         if(Timeout-- == 0)
    
57.         {
    
58.                 return 0;
    
59.         }
    
60.       }
    ) d2 V, B. Z# ~, l
61.     }
    
62. 
    ' e$ u$ A9 Q( ]
63.     /* Restore ADC DMA transfer request after calibration */
    ; n) v3 Y( D# d  e$ e6 f* r
64.     LL_ADC_REG_SetDMATransfer(ADC1, backup_setting_adc_dma_transfer);
    
65. 
    
66.     /* Delay between ADC end of calibration and ADC enable.                   */
    
67.     /* Note: Variable divided by 2 to compensate partially                    */
    ' w* m1 ^' r! d! g. D! t& y1 u$ H
68.     /*       CPU processing cycles (depends on compilation optimization).     */
    
69.     wait_loop_index = (ADC_DELAY_CALIB_ENABLE_CPU_CYCLES >> 1);
    
70.     while(wait_loop_index != 0)
    4 f' Q1 e$ a+ y5 [7 @, s
71.     {
    ' \7 x' {% ?) M* i( d6 S7 @6 A
72.       wait_loop_index--;
    ; u; l' H# B3 U6 G6 O9 z
73.     }
    
74. 
    
75.     /* Enable ADC */
    2 N/ S1 j+ @! ]/ Z* V6 g" C
76.     LL_ADC_Enable(ADC1);
    
77. 
    + ~4 b5 u1 E# {4 ]' ]. f
78.     /* Poll for ADC ready to convert */
    3 C  z% T5 @% S1 t( g' K
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    ( `$ ^: L/ G9 z. y
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    
82.     {
    ) Y9 K* T' k. B0 e
83.       /* Check Systick counter flag to decrement the time-out value */
    
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    
85.       {
    " y0 i/ S5 H7 ?6 o( f- j8 O5 _
86.         if(Timeout-- == 0)
    
87.         {
    
88.                 return 0;
    
89.         }
    + o! _3 Z4 B" C9 X$ Y* S8 v$ Y; v% I6 ^
90.       }
    
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    . v/ M3 |* {# {
93.     /*       status afterwards.                                               */
    2 _" {' h% L8 B! n
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    
96.   }
    
97.   return 1;
    
98. }

复制代码

因为ADC配置的是软件触发的单次采样，所以还需要有手动开始和结束采样的函数。

6 M+ f6 i5 N+ T7 Z使能ADC采样：
% A, o' j5 E/ n3 t% t
4 k* k( p5 `8 P$ Z4 T2 ~

1. uint8_t STM32ADC1SampleEnable(void)
   ' v0 P* G0 E' z- w) y7 v- w
2. {
   
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   1 n/ E+ c+ U& U) r6 ^6 t9 p) j) D
5.     LL_ADC_Enable(ADC1);
   " K. E2 w; }5 U, O3 u2 g% M
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   7 y1 W% X: l% c$ Y. d
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   0 I" }3 @: s& f9 o% f6 [4 f
8.     {
   % _7 M9 @( q& u  K/ ~1 y4 A* X& f
9.           if(Timeout-- == 0)
   + c& `2 k! I# I- |4 @. i. `
10.         {
    
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    6 h- a, t& k3 {: y. K& v
12.                 return 0;
    5 d9 S! n6 w8 |& p* l1 t
13.         }
    
14.     }
    
15.     LL_ADC_REG_StartConversion(ADC1);
    
16.     return 1;
    3 H+ [! ]8 t6 J. g/ q6 S9 X
17. }

复制代码

失能ADC采样：
; _! ~2 V) Q. F" f9 M
% f9 T# |3 N% u0 k7 U

1. uint8_t STM32ADC1SampleDisable(void)
   & `7 l& s! P0 U7 k  c8 f$ O6 y
2. {
   
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   
4.     LL_ADC_REG_StopConversion(ADC1);
   9 L/ F; G) D; M0 K/ {
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   9 ^- V* m/ K: S) V* K
6.     {
   6 i+ S" j- l6 t* j2 p9 A6 u
7.         if(Timeout-- == 0)
   
8.         {
   6 A+ p+ |% }( ~
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   4 h/ j2 z9 w1 A- b) {: G
10.             return 0;
    
11.         }
    
12.     }
    
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    + N. G+ h, }7 T5 N) {. g" h
15.     return 1;
    0 f1 P. }6 f: @5 |! _7 h
16. }

复制代码

进行ADC数据采集流程（采用多次采样求平均值的方式）：
" w. h$ T: P; _  u+ V" X$ m. a8 t
1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；

2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
+ V: ~3 J) r  Z4 J9 |+ s6 c
3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。

/ v. q0 c4 ^; @3 [以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。
% e2 R2 F$ K# ~8 Y1 ~/ {& B
& d) g$ }7 ^) f; B: X4 c" S$ W
# B: K3 R/ C4 K6 P* n8 z- I