说明：驱动基于STm32G031K6测试，其他型号需自行做改动。
5 c; Y! p/ C& ^2 V) J; c
ADC的初始化：
- V! u+ f9 I( d: j: |

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   & _! w! J, \9 P8 M
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   ' I; e' i) X) k: n1 X) @1 {& B# e
3. uint8_t STM32LLADC1Init(void)
   
4. {
   5 s' M$ L# t# X$ ~0 v9 }. E
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   , `6 G) i% d# O: [
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   
7. 
   
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   ! F- l0 \! L% `; c- l1 R( ]6 g- E
9. 
   3 \3 C/ N, J! u1 W" K6 Q. ?0 D
10.   /* Peripheral clock enable */
    
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    # Y9 Y3 o6 L- o! l
12. 
    
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    4 B& n9 f: @" Y' j2 U5 ]0 R7 K2 l
14.   /**ADC1 GPIO Configuration  
    
15.   PA5   ------> ADC1_IN5
    
16.   PA7   ------> ADC1_IN7
    ( t6 y% V$ n; g! g7 k
17.   */
    ' w2 a; t+ J) x' _) O7 @
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    0 L. T1 K% L  H4 Q) x$ I5 Z/ G
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    % `0 s. P' ?+ e$ ]1 l0 ~
22. 
    
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
      Y; {* V, R+ f  A+ D* M+ `& {
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
27. 
    . L" L' m+ j2 B& B$ u; b
28. 
    % }  S  U8 u% R/ `$ x
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    
30.   */
    3 w  H! `7 c; W7 U& H& [
31.   ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;                //ADC定时转化触发条件来源，可以为软件触发或硬件（外部中断、定时器）触发。
    
32.   ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS;     //ADC顺序采集通道的个数，根据自己需要的通道个数设置
      s3 q# Y: f$ @, b
33.   ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;       //
    
34.   ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;                 //采集方式，单次采集还是连续采集
    $ X" E2 h8 ?2 ^( C, |& U
35.   ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED;         //使能DMA，并使用无限传输，如果DMA保存方式为循环覆盖的话才可以使用无限传输。
    8 S' l0 A8 K5 G( d, e; {# E
36.   ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_OVERWRITTEN;               //采集的数据循环覆盖模式
    6 P' [  u4 k, w; ]
37.   LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
    
38.   LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE);                      //失能过采样
    
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使用时不是连续的，所以这里使用可自定义配置
    - |6 O, L# A. {0 Z; c& Q
41.   LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_COMMON_1,     LL_ADC_SAMPLINGTIME_160CYCLES_5);    //设置通道共用取样时间，根据需要自行选择
    
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    
45.   ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;         //采样分辨率
    + f  `# K' ~8 _4 ?
46.   ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;    //采样数据对齐方式，右对齐高位补0，左对齐低位补0.
    & [& w1 ~& V# |. J
47.   ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE;        //低功耗模式，使用DMA的话无法使用，这里关闭
    
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    1 x# P- L7 n; P4 R% O0 }- Z
49.   /** Configure Regular Channel
    ( a! C6 j' o6 e" W4 ?5 P! g: d5 s
50.   */
    
51.   //ADC_RegularChannelConfig
    / ~$ t( b. v1 R6 L2 x7 N
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); //设置通道采样时间
    - K% {$ h1 R* Z1 r1 R% r6 o  H
54.   LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, ADCIO2_IN_CHANNEL);                //将硬件通道ADCIO1_IN_CHANNEL映射到ADC通道2
    ; _5 _' U. N7 i% `7 Z% ]$ H
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
    
56. 
    ! B+ n/ u. K( `# ?/ L8 S3 g
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    ! F/ h; w8 t7 O8 T' h5 f/ X2 w
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;
    , }& n7 X: o0 D6 r
61. }

复制代码

激活并校准ADC：
( V' M8 f5 K. V5 v

1. uint8_t STM32ActivateADC1(void)
   5 _2 w% V7 e: @6 b
2. {
   
3.   __IO uint32_t wait_loop_index = 0U;
   4 o1 i9 e' \4 G1 T6 _3 r( J
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 #####################*/
   # x; m- a1 C. b% m6 B* ?
7. 
   3 l1 `+ i' J! ^4 q" I9 I9 k
8.   /* Note: Hardware constraint (refer to description of the functions         */
   
9.   /*       below):                                                            */
   7 o4 e# v& q, Z# o- z
10.   /*       On this STM32 serie, setting of these features is conditioned to   */
    % G! a2 k4 c. S8 D
11.   /*       ADC state:                                                         */
    0 l- m: g- e% c( }  D0 e$ L
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                */
    * B) d" J) ~0 P% h6 u. B  q
15.   /*       corresponding to reference manual procedure.                       */
    
16.   /*       Software can be optimized by removing some of these checks, if     */
    
17.   /*       they are not relevant considering previous settings and actions    */
    
18.   /*       in user application.                                               */
    
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    
20.   {
    8 f8 m+ u8 l3 d' A
21.     /* Enable ADC internal voltage regulator */
    7 i5 M3 z9 ~( \6 N4 P
22.     LL_ADC_EnableInternalRegulator(ADC1);
    
23. 
    8 C! ^+ ]# K; I& e! j
24.     /* Delay for ADC internal voltage regulator stabilization.                */
    3 P% ]2 n: q1 m, ^
25.     /* Compute number of CPU cycles to wait for, from delay in us.            */
    8 M: y3 d. m" S# v- W
26.     /* Note: Variable divided by 2 to compensate partially                    */
    
27.     /*       CPU processing cycles (depends on compilation optimization).     */
    
28.     /* Note: If system core clock frequency is below 200kHz, wait time        */
    
29.     /*       is only a few CPU processing cycles.                             */
    
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    1 s- f4 I# _6 s
31.     while(wait_loop_index != 0)
    
32.     {
    6 a- i( P% s4 Y& {  ~/ i
33.       wait_loop_index--;
    7 }2 V) L" s" H( H
34.     }
    
35. 
    5 `6 e) s: Q$ J) p; F. b" q/ p
36.     /* Disable ADC DMA transfer request during calibration */
    7 i$ F2 s5 W9 O+ y5 p; L/ @) f* ?3 p
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   */
    
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    $ a# E) X+ E7 M. [9 t
41.     /*       calibration.                                                     */
    
42.     backup_setting_adc_dma_transfer = LL_ADC_REG_GetDMATransfer(ADC1);
    
43.     LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
    ( s; a$ Y+ Z9 ]+ I
44. 
    
45.     /* Run ADC self calibration */
    5 d  \1 q  V6 p
46.     LL_ADC_StartCalibration(ADC1);
    5 {, e$ Q% {0 l8 z! n5 {
47. 
    2 |! O% X2 R: \9 ]  `
48.     /* Poll for ADC effectively calibrated */
    8 K4 r! c' P: L6 Y6 p0 I
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    
50. 
    / B4 Q( R$ u. z3 n3 x* b
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    
52.     {
    
53.       /* Check Systick counter flag to decrement the time-out value */
    ; a) a% [5 v7 H2 `
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    1 m0 E8 R5 ^) `
56.         if(Timeout-- == 0)
    ; }# e0 b  B. P" {
57.         {
    ' w! C# ?- a! d. U2 b/ x& I/ `) T% M8 G- y
58.                 return 0;
    ( N& u3 h' ?; m6 s7 E
59.         }
    
60.       }
    1 E" _6 i( b, v$ \4 o" e% K+ s6 G
61.     }
    / i" @. `$ E8 D% S
62. 
    ( E& {0 Q6 @6 E7 t9 @1 f! l
63.     /* Restore ADC DMA transfer request after calibration */
    $ F* w  A- o. T7 P  Q% m9 }
64.     LL_ADC_REG_SetDMATransfer(ADC1, backup_setting_adc_dma_transfer);
    + N& d. b7 H. o- t3 P# d8 U  `" j
65. 
    
66.     /* Delay between ADC end of calibration and ADC enable.                   */
    
67.     /* Note: Variable divided by 2 to compensate partially                    */
    1 T1 X" G% A  f3 E# L
68.     /*       CPU processing cycles (depends on compilation optimization).     */
    
69.     wait_loop_index = (ADC_DELAY_CALIB_ENABLE_CPU_CYCLES >> 1);
    : L# v. B) c3 ]) d& d& i! t% s
70.     while(wait_loop_index != 0)
    ; d" @1 f5 |& v
71.     {
    
72.       wait_loop_index--;
    & I; S( A% ]9 w
73.     }
    . \: G5 D! f$ r  Y
74. 
    
75.     /* Enable ADC */
    6 j, \  Z9 y' g4 |4 j
76.     LL_ADC_Enable(ADC1);
    4 N+ d+ A' n) }/ N* R! u
77. 
    3 O; q& S3 _# H* j- r; h
78.     /* Poll for ADC ready to convert */
    - t5 q' e0 j& Y6 r
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    6 ]( i; s6 W5 w: O/ X$ M
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    3 k: }& t' n& L; B# @
82.     {
    
83.       /* Check Systick counter flag to decrement the time-out value */
    
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    ; x2 x4 W! w% H
85.       {
    6 s6 y& k* p* R$ b5 P, f" u
86.         if(Timeout-- == 0)
    
87.         {
    6 j, @. G& H: t/ `2 i; o$ A9 Q4 V: b
88.                 return 0;
    
89.         }
    
90.       }
    - O6 D5 G) [( H! x) ^" H, m0 F" l
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    
93.     /*       status afterwards.                                               */
    
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    % ^* x+ ^5 s0 M3 I5 S  o, a) T) L
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
      d2 t% p* R; O3 x, |0 n
96.   }
    
97.   return 1;
    * r6 d$ o3 w, x6 q
98. }

复制代码

因为ADC配置的是软件触发的单次采样，所以还需要有手动开始和结束采样的函数。
# O  q" H+ W1 E& v
使能ADC采样：
. Q9 i( Q3 ~; a

1. uint8_t STM32ADC1SampleEnable(void)
   7 U: m4 s+ K- ~7 x
2. {
   : m2 p+ R  @1 N' x3 r( O# c7 Y# d
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   ! H9 _. ^/ l0 Q( Q: e; ?
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   
5.     LL_ADC_Enable(ADC1);
   9 h; h: d/ b& P
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   7 T% b/ k8 M3 [/ T! Z: C
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   
8.     {
   3 i8 s* _. v. \; x
9.           if(Timeout-- == 0)
   
10.         {
    " K0 A0 d' X" O, e' v; Q
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    3 k& U8 J; h8 [2 W$ ^# t9 X4 ?
12.                 return 0;
    $ ~3 x0 [1 z# y4 g1 N: [$ c" o: }
13.         }
    
14.     }
    % f6 \( K) f" c+ h% {0 n$ h( Y! D
15.     LL_ADC_REG_StartConversion(ADC1);
    7 L; v% d, }; N2 l  B9 U
16.     return 1;
    : ]- P$ g9 f1 A6 _) N, N) h5 u
17. }

复制代码

. e! L& Y' D6 D. g# s! C# i/ @7 ]失能ADC采样：
, Y3 o8 r8 Z) r, w
. w! _  U# [: G

1. uint8_t STM32ADC1SampleDisable(void)
   
2. {
   # i* @# m( Y! L% j# ~# O: O6 w
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   + G7 u$ X, ]3 s2 f3 J
4.     LL_ADC_REG_StopConversion(ADC1);
   : y' f8 u- q) }+ E$ }
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   
6.     {
   
7.         if(Timeout-- == 0)
   
8.         {
   # E- m, f# Y# |, y$ c
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   5 X$ S: ~% d: h2 h# b4 A& A9 a
10.             return 0;
    " q* N, `' S8 u( y) \( e
11.         }
    
12.     }
    
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    
15.     return 1;
    
16. }

复制代码

进行ADC数据采集流程（采用多次采样求平均值的方式）：

8 c2 B# c5 f1 A1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；
& _1 ?7 b& n& C
2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；

3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。

以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。

, {# C& R1 f) D- J2 N6 Y0 y' Q8 z5 U3 t