说明：驱动基于STm32G031K6测试，其他型号需自行做改动。

* N# W; k8 N2 m7 V0 p7 G( h5 FADC的初始化：

9 J+ T6 O/ n0 Z" z7 z

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   
3. uint8_t STM32LLADC1Init(void)
   5 }  f1 e, _- n9 {* `! p
4. {
   , u2 P( P8 u$ y* D
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   
7. 
   
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   2 `, k/ F- \. ?( m7 I
9. 
   
10.   /* Peripheral clock enable */
    
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    ) d3 V) Z: {  `+ ~! G7 E
12. 
    5 E; B2 j" X$ Z8 z2 g
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    7 `; K2 |* u8 ~! ]& V! ^
14.   /**ADC1 GPIO Configuration  
    0 @& f) E+ l) r( n7 x9 ^3 U2 q
15.   PA5   ------> ADC1_IN5
    ( @" m( [1 x& w. b
16.   PA7   ------> ADC1_IN7
    
17.   */
    , ~$ h6 F9 B, n4 p9 W
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    . K# N! l: v) _% x" b8 I
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
22. 
    7 C( |& M/ c9 t0 G2 r& {% i
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    4 O: J' {4 v8 n: P
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
27. 
    
28. 
    8 t" w: U; `( ~2 V
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    2 T& l& q/ {; H9 h2 k- Z; k
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;       //
    ) ]# U/ Q6 I& p! {* U
34.   ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;                 //采集方式，单次采集还是连续采集
    . Q9 U9 J; K: h1 K# k
35.   ADC_REG_InitStruct.DMATransfer = LL_ADC_REG_DMA_TRANSFER_UNLIMITED;         //使能DMA，并使用无限传输，如果DMA保存方式为循环覆盖的话才可以使用无限传输。
    
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);                      //失能过采样
    . m4 a# ^4 R& Z0 |! `! @1 F, `
39.   LL_ADC_SetTriggerFrequencyMode(ADC1, LL_ADC_CLOCK_FREQ_MODE_HIGH);          //采样时钟使用高频模式
    - {# o7 e, I% e
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);    //设置通道共用取样时间，根据需要自行选择
    
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    5 e" V" D% z; ~1 J6 `' c
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    
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的话无法使用，这里关闭
    & K1 o  u1 A) B% ~, z, S5 {% v( @5 X
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    & G& N- _2 W5 \
49.   /** Configure Regular Channel
    
50.   */
    # Q. Q. x+ R0 H" _
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
    ) B; N4 E  ^. ^0 a9 [0 i0 s/ C1 @
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
    
56. 
    ; M: b% s3 A5 @1 w
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    
58.   //LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_VREFINT);
    + q4 E6 x: x" b+ P
59.   //LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_VREFINT, LL_ADC_SAMPLINGTIME_COMMON_1);
    % n, C9 o3 X5 E: f
60. return 1;
      @+ i$ M% O1 K6 I  v4 c
61. }

复制代码

" n5 o0 k7 [7 }5 |激活并校准ADC：
8 j- t/ |$ Z9 u$ N3 G
( x5 P: |- r# V5 {8 d$ e

1. uint8_t STM32ActivateADC1(void)
   ) J4 D" ?* `' t& }" h5 s
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 #####################*/
   2 {5 H" ?: h+ ~' ^* ~7 ]- ]6 W
7. 
   
8.   /* Note: Hardware constraint (refer to description of the functions         */
   
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        */
    4 I$ f0 K+ i3 a/ j) _
14.   /*       implemented anyway to show the best practice usages                */
    / v4 J6 i5 P; j, X7 [# }0 n
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.                                               */
    ) H( ~" L0 B- t* R1 t: q
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    
20.   {
    
21.     /* Enable ADC internal voltage regulator */
    
22.     LL_ADC_EnableInternalRegulator(ADC1);
    8 M1 v6 D9 d1 ~8 U8 e2 `1 i
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).     */
    5 ?1 T) Z; H4 m/ P' D4 G& a
28.     /* Note: If system core clock frequency is below 200kHz, wait time        */
      x; U& P9 R/ }& I
29.     /*       is only a few CPU processing cycles.                             */
    & n8 B4 |' b" i% e6 r6 ^! Z( V
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    
31.     while(wait_loop_index != 0)
    
32.     {
    # Y7 x. w( ]4 V6 c# X4 H
33.       wait_loop_index--;
    $ w% W  p5 w  {* O* i: F
34.     }
    
35. 
      Z' ~5 m0 N$ k
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.           */
    " z3 P; B$ a& F9 G& U
39.     /*       To not insert ADC calibration factor among ADC conversion data   */
    ; O) P0 k, K, t; [1 V! Y' m
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    
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);
    ( a5 @9 c. }5 z- A. l) o" _1 ^0 V4 v9 a
44. 
    & s, b! w6 M$ g1 t2 F
45.     /* Run ADC self calibration */
    5 z" s6 J- z4 l4 a9 d' g3 f
46.     LL_ADC_StartCalibration(ADC1);
    8 `4 o8 Q8 e- {5 M! y! L9 O: H
47. 
    4 G% \; p5 k& ^+ {7 R0 I0 M2 N, {
48.     /* Poll for ADC effectively calibrated */
    ; `& C7 v2 q2 y9 a
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    
50. 
    
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    
52.     {
    . e8 r1 O" J( u( F8 r' {
53.       /* Check Systick counter flag to decrement the time-out value */
    
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    8 v* C: m7 m; ?" Y( |# U2 {
56.         if(Timeout-- == 0)
    ( u7 T8 D& T+ P: w/ A( v5 w
57.         {
    : j2 z6 L# f" [
58.                 return 0;
    ( l* J& X" d/ G+ [* A
59.         }
    8 ~5 {/ v! d% y# A7 e  s% Z0 Z
60.       }
    , Y; ?. k9 \0 A
61.     }
    0 C( c, ?2 Q- c9 H% w
62. 
    & ^0 M* V7 g7 V6 G  b$ w( C6 G+ y0 N
63.     /* Restore ADC DMA transfer request after calibration */
    ' I; j& I- c3 w& p( Q4 u
64.     LL_ADC_REG_SetDMATransfer(ADC1, backup_setting_adc_dma_transfer);
    : r- X/ d: ?, k; K
65. 
    9 W/ x4 p" ]) H6 S- J# R
66.     /* Delay between ADC end of calibration and ADC enable.                   */
    
67.     /* Note: Variable divided by 2 to compensate partially                    */
    $ t  }) D4 [( l: K7 g8 `4 L
68.     /*       CPU processing cycles (depends on compilation optimization).     */
    5 x  J, H& L: A7 w, b3 P! V
69.     wait_loop_index = (ADC_DELAY_CALIB_ENABLE_CPU_CYCLES >> 1);
    
70.     while(wait_loop_index != 0)
    0 W6 O. M$ L: K+ Q$ R) Z. [
71.     {
      i: r/ W+ I+ M0 Q
72.       wait_loop_index--;
    7 [, ~; G2 ~4 a: e. Z' W$ m; ^
73.     }
    
74. 
    
75.     /* Enable ADC */
    
76.     LL_ADC_Enable(ADC1);
    
77. 
    ; _  k4 K- W3 ~  b" V2 p4 r
78.     /* Poll for ADC ready to convert */
    2 w, ^; o) J. ]
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    ( M/ [5 i) j- p( |- K
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    $ N1 m6 e" l) ?
82.     {
    
83.       /* Check Systick counter flag to decrement the time-out value */
    9 }4 b. o" x  z6 u
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    # h6 m9 {$ R( @5 f
85.       {
    
86.         if(Timeout-- == 0)
    / p* _, _, ^* S: ]/ j( T
87.         {
    
88.                 return 0;
    
89.         }
    . Y# F) A2 J9 c4 I2 o3 u: b1 P  U
90.       }
    2 c9 S0 D8 r& q5 s- C- u7 E
91.     }
    4 X: o" o, T, u- b
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    5 w5 a9 B  z' T$ y. U. C
93.     /*       status afterwards.                                               */
    
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    . ]+ d9 V4 I3 {$ n+ t
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    
96.   }
      c. _& t: G* J" F; I4 i
97.   return 1;
    % O# |6 ^* @& E! a" \+ m. D
98. }

复制代码

因为ADC配置的是软件触发的单次采样，所以还需要有手动开始和结束采样的函数。
$ t: c! ~- ]/ l1 I- w# `# K
使能ADC采样：
' D0 R0 g+ U* ]$ j; c9 `6 {- I; n/ d
+ r8 z* R, _4 r  L0 d3 [. a4 u

1. uint8_t STM32ADC1SampleEnable(void)
   ( w: ~" v1 v: G1 E" C
2. {
   
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   : ~4 z: B2 Y3 z0 m
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   7 v& s: `& |3 R& I2 ]7 {- _
5.     LL_ADC_Enable(ADC1);
   4 z+ G7 M; P1 N8 k) `  ~% A& i5 b
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   * e* G+ i2 j; C
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   
8.     {
   
9.           if(Timeout-- == 0)
   
10.         {
    
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    
12.                 return 0;
    ( m9 _& P3 J( h! P1 @# Y
13.         }
    
14.     }
    
15.     LL_ADC_REG_StartConversion(ADC1);
    # I1 ~- O( D: P" z& L, W* z
16.     return 1;
    
17. }

复制代码

  W5 W6 K* ], b8 q, M" Q0 q失能ADC采样：

! ^6 {5 W. `  z+ q

1. uint8_t STM32ADC1SampleDisable(void)
   
2. {
   
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   
4.     LL_ADC_REG_StopConversion(ADC1);
   
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   
6.     {
   
7.         if(Timeout-- == 0)
   
8.         {
   
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   . y# p3 w; F% Q' `/ H/ ?+ }- a3 b4 [
10.             return 0;
    : u2 T% D4 p& I6 r
11.         }
    / V8 C4 v1 O! W$ G3 q
12.     }
    
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    
15.     return 1;
    * X! [6 u. \' u  H6 [1 k# N
16. }

复制代码

- @+ w1 i% @/ S( K/ B; j+ `* P6 s; l进行ADC数据采集流程（采用多次采样求平均值的方式）：
7 h1 I' |, g6 s+ ~: j0 g
1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；

2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
" a( L; u. d' {4 _, q& ]
3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。

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

* U! V) X+ D& r7 d/ d% D; U