说明：驱动基于STm32G031K6测试，其他型号需自行做改动。
- I( Z* Z% _1 g; j% X
* R4 [5 W: @: ?. l8 M  @# ZADC的初始化：

. B+ v6 _. O) k5 {; f, z2 Q) Z

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   
3. uint8_t STM32LLADC1Init(void)
   
4. {
   
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   7 C' v6 [; S9 e- a" P+ X% y8 f
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   
7. 
   . g5 [0 R8 x9 C( I2 A. P. G
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   
9. 
   - Z: O: K) L8 t3 |
10.   /* Peripheral clock enable */
    + d9 _! ?/ I+ |$ M
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    2 Y6 }( h2 T" X8 i& A4 Z  \1 p/ a
12. 
    ( h8 n! J7 W' {# m+ n8 T6 ~. f
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    ; R/ K4 o2 n' C4 B# y7 f2 s
14.   /**ADC1 GPIO Configuration  
    9 O& C7 U/ S( U. H6 z- z
15.   PA5   ------> ADC1_IN5
    9 R9 Y3 w+ A) t* f  Z
16.   PA7   ------> ADC1_IN7
    ; o( D5 P( O6 ?' d# t/ K# ^; O
17.   */
    
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
22. 
    
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    " k2 b# {3 f& t/ M/ v& P3 e' D
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    : E9 V8 r" B( H* t* O
27. 
    
28. 
      |0 T( {  _1 u
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    & {3 z% X. M6 C% `) O9 t* z
30.   */
    
31.   ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;                //ADC定时转化触发条件来源，可以为软件触发或硬件（外部中断、定时器）触发。
    
32.   ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS;     //ADC顺序采集通道的个数，根据自己需要的通道个数设置
    
33.   ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;       //
    % R1 v, X$ E# z0 d  P
34.   ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;                 //采集方式，单次采集还是连续采集
    
35.   ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED;         //使能DMA，并使用无限传输，如果DMA保存方式为循环覆盖的话才可以使用无限传输。
    4 p2 O; }( X) R3 _- p9 l
36.   ADC_REG_InitStruct.Overrun = LL_ADC_REG_OVR_DATA_OVERWRITTEN;               //采集的数据循环覆盖模式
    
37.   LL_ADC_REG_Init(ADC1, &ADC_REG_InitStruct);
    * o5 y4 |* ~' m1 G9 [* F
38.   LL_ADC_SetOverSamplingScope(ADC1, LL_ADC_OVS_DISABLE);                      //失能过采样
    : [; E) v9 R+ ?( R
39.   LL_ADC_SetTriggerFrequencyMode(ADC1, LL_ADC_CLOCK_FREQ_MODE_HIGH);          //采样时钟使用高频模式
    . [, g) L0 n, z1 ?- C
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);    //设置通道共用取样时间，根据需要自行选择
    $ R& t. I- P$ e1 o4 `5 L* K* K- ~
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    ; t1 P6 b3 J# }4 V, F: V
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    2 P6 x% r. [* l# P6 N8 @' v+ a
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的话无法使用，这里关闭
    / B6 @4 g4 ^$ |& x8 L
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    / m5 l4 L3 B) z9 R8 f2 m  |" L  ?
49.   /** Configure Regular Channel
    1 G; v& J; w, \9 O" X1 `2 V8 }
50.   */
    
51.   //ADC_RegularChannelConfig
    
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);  //设置通道采样时间
    
56. 
    
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    0 ^. Y7 L! @# J5 S! G7 P' {
58.   //LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_VREFINT);
    - U% y0 k1 u- R9 c: t
59.   //LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_VREFINT, LL_ADC_SAMPLINGTIME_COMMON_1);
    + D4 w" w; [7 J8 G3 \
60. return 1;
    0 w4 h  I8 R# x/ X( q
61. }

复制代码

激活并校准ADC：
. q4 q3 z8 f" s, t) W0 Q$ g' z. B' P* z
+ ~/ X- C/ L; f7 v  f5 d

1. uint8_t STM32ActivateADC1(void)
   
2. {
   $ b+ n6 I. L& Y2 e& \
3.   __IO uint32_t wait_loop_index = 0U;
   
4.   __IO uint32_t backup_setting_adc_dma_transfer = 0U;
   - K& C/ X) ^- J% T" v  I0 W  r9 L
5.   uint32_t Timeout = 0U; /* Variable used for timeout management */
   
6.   /*## Operation on ADC hierarchical scope: ADC instance #####################*/
   ) A; `  O3 V3 U7 }+ T0 O' @1 b
7. 
   % P/ q6 M9 e) V* A  `/ x
8.   /* Note: Hardware constraint (refer to description of the functions         */
   
9.   /*       below):                                                            */
   + V' m# ^  O1 R0 X9 a1 y: A' Q
10.   /*       On this STM32 serie, setting of these features is conditioned to   */
    
11.   /*       ADC state:                                                         */
    
12.   /*       ADC must be disabled.                                              */
    0 J3 M# s8 {7 d
13.   /* Note: In this example, all these checks are not necessary but are        */
    
14.   /*       implemented anyway to show the best practice usages                */
    % }6 U8 }. s/ j% }3 M
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    */
    & u2 I/ c* R2 S: r& x% z7 k, z
18.   /*       in user application.                                               */
    ) }# m! O* \* P
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    - K' @0 y* u& E9 S) l! J
20.   {
    
21.     /* Enable ADC internal voltage regulator */
    " [" F- s: {+ [3 j3 \( z2 A' b% H
22.     LL_ADC_EnableInternalRegulator(ADC1);
    
23. 
    
24.     /* Delay for ADC internal voltage regulator stabilization.                */
    
25.     /* Compute number of CPU cycles to wait for, from delay in us.            */
    
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);
    9 i# ~# n9 t0 O
31.     while(wait_loop_index != 0)
    
32.     {
    & ]% H3 t  o; ~1 Q: S. [
33.       wait_loop_index--;
    7 a$ R+ h4 S+ u! W  D  L) z3 |2 l
34.     }
    
35. 
    ( u, ^* Z" r3 ~
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   */
    
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    * p+ H2 k" g5 o
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);
    - j2 ^( z2 J3 n
44. 
    
45.     /* Run ADC self calibration */
    
46.     LL_ADC_StartCalibration(ADC1);
    # J  B6 A/ K' H) E( c0 R1 [% |  J
47. 
    
48.     /* Poll for ADC effectively calibrated */
    
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    & B% U. M% \  D3 r' k2 b
50. 
    
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    ' L. ?2 n& L$ P  [  o, |
52.     {
    
53.       /* Check Systick counter flag to decrement the time-out value */
    + L. s! z+ v+ s
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    6 K4 u6 M- t  n
56.         if(Timeout-- == 0)
    8 {2 C  F4 X0 W( f$ s; H4 a- x
57.         {
    
58.                 return 0;
    ! Y. m& u7 R4 G% {
59.         }
    
60.       }
    2 q# K$ `' X) Q5 `, }5 [( A9 F& {
61.     }
    
62. 
    
63.     /* Restore ADC DMA transfer request after calibration */
    
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                    */
    
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)
    
71.     {
    
72.       wait_loop_index--;
    
73.     }
    
74. 
    8 F* e3 d/ s/ r5 i
75.     /* Enable ADC */
    
76.     LL_ADC_Enable(ADC1);
    " v) g* p; J6 }
77. 
    . I" E8 G! X& a1 c6 R; v
78.     /* Poll for ADC ready to convert */
    / H/ i( }) B/ j9 L* @1 B8 M
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    1 x' k( g: |- P% i8 V
82.     {
    
83.       /* Check Systick counter flag to decrement the time-out value */
    1 @. a* U' S8 d+ p. _2 B
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    6 K- U9 C' B( M
85.       {
    
86.         if(Timeout-- == 0)
    
87.         {
    7 _! @" ^% H+ o, l$ l$ e0 T+ ~
88.                 return 0;
    ' I' a+ ^3 [: ?+ _
89.         }
    * x$ q/ ]$ V8 n3 _3 p+ Z) s% t
90.       }
    4 M& o2 ]" a( u/ o  U( P% R
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    $ k( `5 Q  Z* h, L: l
93.     /*       status afterwards.                                               */
    
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    ' S  V6 p0 s6 R  W6 a( `
96.   }
    
97.   return 1;
    0 i9 b8 f: Q- f, A' o1 d
98. }

复制代码

- h4 N+ }2 B& j# e因为ADC配置的是软件触发的单次采样，所以还需要有手动开始和结束采样的函数。
& r; {# ]- B' L; i) x
使能ADC采样：
$ ]8 ~! a* W6 |- E/ g% e

1. uint8_t STM32ADC1SampleEnable(void)
   
2. {
   
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   " `" [! q& R& [# g+ [  W4 E. X
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   
5.     LL_ADC_Enable(ADC1);
   / B( C. h; [6 C  ]
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   . h. M" k, C2 i5 _4 [% @" W
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   
8.     {
   
9.           if(Timeout-- == 0)
   + \5 y# k3 X% D% |( }) x
10.         {
    
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    
12.                 return 0;
    7 s/ H$ V: I; x8 w
13.         }
    : A; c7 ?( O: G  A  k1 x( \/ @( r
14.     }
    ) u: z" J& a( ?
15.     LL_ADC_REG_StartConversion(ADC1);
    " r+ l" T1 H- K2 _- A- a& X3 w
16.     return 1;
    
17. }

复制代码

失能ADC采样：
" x- @8 U+ W1 ]1 B2 l& C

1. uint8_t STM32ADC1SampleDisable(void)
   & Z' P! X( \$ o
2. {
   * W& ~7 \- g3 y  C" j  S
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   8 p7 G& Y% @& Z  r
4.     LL_ADC_REG_StopConversion(ADC1);
   
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   0 x; \0 @$ C2 G
6.     {
   " |$ ?8 o" b/ |' U- u0 K, x' Z
7.         if(Timeout-- == 0)
   
8.         {
   
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   7 m. X. L# n/ U/ S0 @  \$ G# _
10.             return 0;
    ; Q' E0 @0 z2 @
11.         }
    
12.     }
    
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    4 b! e& T  e& {6 f8 a8 k% M
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    / s& }5 h; c* U9 {' T7 v; K
15.     return 1;
    8 L% W4 x( t6 _" z
16. }

复制代码

进行ADC数据采集流程（采用多次采样求平均值的方式）：
, ]8 h, R4 s5 w' R2 L# B& |
1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；

2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
9 D* M) F7 b; E- _0 @
3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。

2 E& \$ F/ E9 D; K( ^' B. n以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。

7 ]2 i3 t* l- x( O* G+ R
  f, F" b7 X8 A! ]9 D4 X