说明：驱动基于STm32G031K6测试，其他型号需自行做改动。
+ Y: ?, ^" t+ X& i
ADC的初始化：
* m$ O/ n4 p" y
' }* c8 k) T; n/ v0 u) S

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   8 F* T1 p* e/ A& K. A
3. uint8_t STM32LLADC1Init(void)
   0 m- z% i( U1 y: P
4. {
   
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   2 f8 P- c5 ~  ^4 w
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   
7. 
   
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   
9. 
   + k6 [- X( E% G% p! N' s5 ]4 u5 f
10.   /* Peripheral clock enable */
    
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    - k5 I$ f" k! u
12. 
    
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    
14.   /**ADC1 GPIO Configuration  
    
15.   PA5   ------> ADC1_IN5
    
16.   PA7   ------> ADC1_IN7
    
17.   */
    # B7 W  I, e+ a
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    ' N$ h2 _6 l: n: z/ F6 s! L- E
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
22. 
    
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    6 k6 ~) I- x0 U$ V! d/ c
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    2 b$ L# X4 _/ Q7 h( ~- X  Z
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
27. 
    0 g- V5 n. V! p# `6 \
28. 
    
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    6 `0 F9 x3 @9 x) L
30.   */
    6 H% q. p/ G' K7 U" g/ G) Z( I  d# ?
31.   ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;                //ADC定时转化触发条件来源，可以为软件触发或硬件（外部中断、定时器）触发。
    
32.   ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS;     //ADC顺序采集通道的个数，根据自己需要的通道个数设置
    : M9 {6 I6 A$ u( u1 ^3 k
33.   ADC_REG_InitStruct.SequencerDiscont = LL_ADC_REG_SEQ_DISCONT_DISABLE;       //
    
34.   ADC_REG_InitStruct.ContinuousMode = LL_ADC_REG_CONV_SINGLE;                 //采集方式，单次采集还是连续采集
    
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);                      //失能过采样
    8 A2 M" n8 g2 Y% M! f
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);    //设置通道共用取样时间，根据需要自行选择
    3 r; I$ q" {# r* D
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    * z' _/ g' e* f' p; K- V3 h
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    * b; X( Y& x8 i7 C; k/ ~
45.   ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;         //采样分辨率
    1 p" Q: E) x3 r) w7 b2 e+ ?) W
46.   ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;    //采样数据对齐方式，右对齐高位补0，左对齐低位补0.
    , v  x; ~  O  h: ]) X
47.   ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE;        //低功耗模式，使用DMA的话无法使用，这里关闭
    ' A" k, N- B& {# M
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    $ R+ h: \& p# y& \, o; ]5 \( Z
49.   /** Configure Regular Channel
      G/ B4 z) h' [7 R$ T; _5 C
50.   */
    " k$ c. F5 V) o! k( a. X
51.   //ADC_RegularChannelConfig
    $ G" X3 n3 v& ^+ R4 O9 M4 {* b& W/ _0 M
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
    + i# Y8 v7 F: P2 k3 I) k3 X, ^
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
      n! `$ ]3 C, F2 Y" ^8 ^: E
56. 
    
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    
58.   //LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_4, LL_ADC_CHANNEL_VREFINT);
    " C' z( A. G- C
59.   //LL_ADC_SetChannelSamplingTime(ADC1, LL_ADC_CHANNEL_VREFINT, LL_ADC_SAMPLINGTIME_COMMON_1);
    
60. return 1;
    
61. }

复制代码

: e, e; z7 U! C; a激活并校准ADC：
7 v8 y( d+ _( l8 |9 d0 R/ X4 ?: _

1. uint8_t STM32ActivateADC1(void)
   
2. {
   ' ?+ k4 Q( H  i) j. L
3.   __IO uint32_t wait_loop_index = 0U;
   ; c2 X% i7 g$ V8 K
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 #####################*/
   8 }& {7 w, u+ i! h# |! I0 R! u
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   */
    8 f0 T# C1 `# B4 S" q
11.   /*       ADC state:                                                         */
      l3 [. E6 v- E! q/ H6 k
12.   /*       ADC must be disabled.                                              */
    
13.   /* Note: In this example, all these checks are not necessary but are        */
    7 s/ h7 Y) u3 @1 ]/ v5 I
14.   /*       implemented anyway to show the best practice usages                */
    
15.   /*       corresponding to reference manual procedure.                       */
    6 n) P- \9 C' I6 J) K
16.   /*       Software can be optimized by removing some of these checks, if     */
    * Y9 e  D, r" X8 E
17.   /*       they are not relevant considering previous settings and actions    */
    
18.   /*       in user application.                                               */
    
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    
20.   {
    
21.     /* Enable ADC internal voltage regulator */
    5 r& ?5 G/ z9 Z2 Z3 A4 o+ ]  J
22.     LL_ADC_EnableInternalRegulator(ADC1);
      R0 r0 m1 K: s: i
23. 
    1 s) j# E$ O& a0 d2 S5 G6 f) b
24.     /* Delay for ADC internal voltage regulator stabilization.                */
    
25.     /* Compute number of CPU cycles to wait for, from delay in us.            */
    " H' G7 `0 a1 N2 x
26.     /* Note: Variable divided by 2 to compensate partially                    */
    
27.     /*       CPU processing cycles (depends on compilation optimization).     */
    5 c, a8 Q% y) l# J/ n! ^! h' F% @
28.     /* Note: If system core clock frequency is below 200kHz, wait time        */
    
29.     /*       is only a few CPU processing cycles.                             */
    ; N/ ^$ d0 f: p/ u- b
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    % h/ X+ P8 m# z8 r4 A+ e. y* |
31.     while(wait_loop_index != 0)
    2 \$ v6 t% ^" u: z4 h) N
32.     {
    
33.       wait_loop_index--;
    
34.     }
    0 z" h1 T& A3 q: f9 d
35. 
    
36.     /* Disable ADC DMA transfer request during calibration */
    , `1 p' U. o* d6 t: j1 K
37.     /* Note: Specificity of this STM32 serie: Calibration factor is           */
    
38.     /*       available in data register and also transfered by DMA.           */
    9 a5 W1 S5 \( K* q% Q2 L: R) _. t0 ?
39.     /*       To not insert ADC calibration factor among ADC conversion data   */
    
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    
41.     /*       calibration.                                                     */
    - M2 P4 }0 Y! r0 y! Q
42.     backup_setting_adc_dma_transfer = LL_ADC_REG_GetDMATransfer(ADC1);
    
43.     LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
    
44. 
    # I$ k) y8 D% k& S" u3 k% G, x
45.     /* Run ADC self calibration */
    
46.     LL_ADC_StartCalibration(ADC1);
    
47. 
    
48.     /* Poll for ADC effectively calibrated */
      y# L& u1 V! X! E/ c! n- Q+ ?
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    
50. 
    
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    
52.     {
    # |# V' U% }4 R: o; h# V& m
53.       /* Check Systick counter flag to decrement the time-out value */
    
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    
56.         if(Timeout-- == 0)
    
57.         {
    * H! ]) i* v  T3 ^% N0 `$ ?
58.                 return 0;
    $ V/ T, }: r) F
59.         }
    ) E8 ^' A4 p! ^" Z! S
60.       }
    0 t" I) U5 C: O4 V
61.     }
    9 r; H; T8 }+ g, A: \
62. 
    3 r- H# c) N* d
63.     /* Restore ADC DMA transfer request after calibration */
    & r. K$ M. p- W& g
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).     */
    % k/ G% k# m. T1 _7 |. U; U# a
69.     wait_loop_index = (ADC_DELAY_CALIB_ENABLE_CPU_CYCLES >> 1);
    
70.     while(wait_loop_index != 0)
    
71.     {
    
72.       wait_loop_index--;
    , f5 h) h; W0 ~( S$ V
73.     }
    
74. 
    
75.     /* Enable ADC */
    $ H4 U4 S: \4 a+ R, l
76.     LL_ADC_Enable(ADC1);
    6 d* Y6 W' Q' n' E. A
77. 
    8 d- |! n! A3 V0 i, p  t: P8 u, ^
78.     /* Poll for ADC ready to convert */
    
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    
82.     {
    3 I& Z3 m0 y5 o& O/ a
83.       /* Check Systick counter flag to decrement the time-out value */
    3 D2 h9 J1 @! |) P
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    
85.       {
    ; l2 \/ s( }' z$ O! g% _% n
86.         if(Timeout-- == 0)
    + \  x8 c" B) H$ c$ J3 f! d
87.         {
    ; _, i; g9 X# T
88.                 return 0;
    3 p( m) w2 r& [+ f. A
89.         }
    
90.       }
    - o, {7 R8 t+ }% t1 y+ X9 `
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    
93.     /*       status afterwards.                                               */
    , C1 D1 g# Z- T8 }! E( ^
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    4 {6 v6 z0 @# @! c4 ?5 ?( h$ G
96.   }
    
97.   return 1;
    
98. }

复制代码

4 ?1 z. _& X3 `$ |2 ~# i$ i因为ADC配置的是软件触发的单次采样，所以还需要有手动开始和结束采样的函数。
: U: w: {) B4 G" q2 e
使能ADC采样：

1. uint8_t STM32ADC1SampleEnable(void)
   6 J9 k( @5 [0 y# `7 W
2. {
   
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   % H; i: d! r7 ^9 N  f
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   
5.     LL_ADC_Enable(ADC1);
   6 {; }6 _" ~- m" ^' i) m7 n
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   6 {- \4 D  M  W$ `6 |
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   
8.     {
   . e$ e& \: J8 |: z" A& M: P5 _% V
9.           if(Timeout-- == 0)
   
10.         {
    
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
      J" g3 o  g- R5 y
12.                 return 0;
    
13.         }
    ! w" c7 Y4 Z& U
14.     }
    
15.     LL_ADC_REG_StartConversion(ADC1);
    ! N+ q+ X- M8 J, o
16.     return 1;
    
17. }

复制代码

失能ADC采样：
  ]8 Q0 B5 R- K. c! L5 P
; `8 C% P9 Y$ c, Q( ^4 N/ J

1. uint8_t STM32ADC1SampleDisable(void)
   7 X2 V# }$ Q0 w& h: W& i( H5 l
2. {
   / \5 p8 B+ f7 U
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   * `7 {, c5 w6 U) I# i
4.     LL_ADC_REG_StopConversion(ADC1);
   
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   
6.     {
   
7.         if(Timeout-- == 0)
   
8.         {
   6 E: s0 Q% ]1 J# D- Z
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   
10.             return 0;
    
11.         }
    
12.     }
    : e/ ?0 K, B6 Z" w/ H! x! ^' ~
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    
15.     return 1;
    
16. }

复制代码

$ M- C0 N: _5 ^& H2 {进行ADC数据采集流程（采用多次采样求平均值的方式）：

, f: L# I2 d. e1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；
) N3 c. H  L& Z' Q. r
2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
' x3 u7 _& j5 b' g- j
3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。

/ D- c/ G; U1 R9 x7 v2 ]" i/ U6 M以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。