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

ADC的初始化：
9 G8 @4 W1 h: t9 Y; ^: j

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
     A7 t5 D) u; `0 C/ m7 e! T0 T0 u' w
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   
3. uint8_t STM32LLADC1Init(void)
   
4. {
   2 [9 D/ a: ^" h. {( n& ~
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   
7. 
   
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   
9. 
     H2 j1 H3 Q0 R% k
10.   /* Peripheral clock enable */
    % l% k( ?+ a1 _' l- C, }/ p
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    , ?- |! w: }' y8 @3 a0 _
12. 
    + P0 W$ ?: E" F5 O
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    ) e7 B% D& {' d2 [. L5 v8 t
14.   /**ADC1 GPIO Configuration  
    
15.   PA5   ------> ADC1_IN5
    
16.   PA7   ------> ADC1_IN7
    $ V  |, O5 f/ D
17.   */
    / n) G  T& F/ F+ [0 W& \* F3 C
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    
19.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    0 F3 E, \3 s# a. a9 V" Q* T- V3 d9 B: i
20.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
21.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    ) J) f  ^/ N+ D+ I) |4 k, Q' s
22. 
    ( o0 g. d/ |, b/ N/ |- k
23.   GPIO_InitStruct.Pin = gpioADCIO2_IN_PIN;
    
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    - N2 Y6 ~: f4 m" _0 y
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    " I  ~& @( r1 b' g0 \# e0 ]2 y( C
27. 
    
28. 
    % O0 }* c7 Y, A8 a% ]# ]
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    
30.   */
    ! R& F' s% T% i. ]
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;       //
    , \! t8 V0 A, P& {  D2 ?, q
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;               //采集的数据循环覆盖模式
    & z  L( B2 `9 n7 y7 y' C
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);          //采样时钟使用高频模式
    + D2 S* v# d+ P3 M9 k" R3 ~
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);    //设置通道共用取样时间，根据需要自行选择
    # D* d* ^5 Z4 L& A8 q5 I
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    $ G( z2 g3 J3 g+ N
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    
44.   ADC_InitStruct.Clock = LL_ADC_CLOCK_SYNC_PCLK_DIV2;        //选择采样时钟来源
    % K1 w" k, b' Z, C) @8 b0 t
45.   ADC_InitStruct.Resolution = LL_ADC_RESOLUTION_12B;         //采样分辨率
    & j: H' m' |  |3 @4 y# K; _
46.   ADC_InitStruct.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;    //采样数据对齐方式，右对齐高位补0，左对齐低位补0.
    ( c, [8 V/ @2 i& c5 O
47.   ADC_InitStruct.LowPowerMode = LL_ADC_LP_MODE_NONE;        //低功耗模式，使用DMA的话无法使用，这里关闭
    
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    ' o- X2 |: K( B& R8 i
49.   /** Configure Regular Channel
    
50.   */
    % y, _, ?) s5 U' {9 t
51.   //ADC_RegularChannelConfig
    3 d' _" `* G0 Q  n( g# ]
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); //设置通道采样时间
      w0 R4 o! o6 A! Q- J
54.   LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, ADCIO2_IN_CHANNEL);                //将硬件通道ADCIO1_IN_CHANNEL映射到ADC通道2
    % {9 x0 G/ o4 U
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
    , H& x3 N, ~* t/ Z' n( L
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;
    & p2 |! c. R( k7 ^7 g- P
61. }

复制代码

" n4 J! q) m7 E. T8 F1 k激活并校准ADC：

5 t! ^8 R2 |* |' Z0 _. A5 F; Y

1. uint8_t STM32ActivateADC1(void)
   & t7 k1 d% [) C  k$ U
2. {
   
3.   __IO uint32_t wait_loop_index = 0U;
   
4.   __IO uint32_t backup_setting_adc_dma_transfer = 0U;
   4 C1 R+ O# F/ }* u! |
5.   uint32_t Timeout = 0U; /* Variable used for timeout management */
   2 J4 {, _6 `, O5 s! f
6.   /*## Operation on ADC hierarchical scope: ADC instance #####################*/
   3 r7 l0 \4 s& o
7. 
   , @4 n7 E' L- H! O4 d7 y5 `% w
8.   /* Note: Hardware constraint (refer to description of the functions         */
   
9.   /*       below):                                                            */
   0 i) o# ]% g- c' ]  {- E$ R
10.   /*       On this STM32 serie, setting of these features is conditioned to   */
    8 L( g: _: ]1 M" R
11.   /*       ADC state:                                                         */
    * X; x5 n  E8 N% o4 F9 U
12.   /*       ADC must be disabled.                                              */
    
13.   /* Note: In this example, all these checks are not necessary but are        */
    6 X6 E) |0 ]0 y: h4 l$ M
14.   /*       implemented anyway to show the best practice usages                */
    ; U: Y7 w$ [% R
15.   /*       corresponding to reference manual procedure.                       */
    / Q& e: x5 r9 g5 P* C" N% \; p
16.   /*       Software can be optimized by removing some of these checks, if     */
    - s$ i4 }- Y1 ^. q) ^- x  u$ j" ]6 t
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 */
    " G" m8 e' H% G$ F4 _% Y: i, t
22.     LL_ADC_EnableInternalRegulator(ADC1);
    
23. 
    0 [) Q: _: {) J
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                    */
    ( g$ D% X- D9 M
27.     /*       CPU processing cycles (depends on compilation optimization).     */
    
28.     /* Note: If system core clock frequency is below 200kHz, wait time        */
    ( e$ t" o8 e. o8 H# @! p: z$ |
29.     /*       is only a few CPU processing cycles.                             */
    , ~. f' s7 b4 j; |* B
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    ) ^6 f8 ?4 ^7 L
31.     while(wait_loop_index != 0)
    # x! W; O, _) `3 }  ]3 n6 c
32.     {
    % o) O/ d) w% V" C  e3 |# G
33.       wait_loop_index--;
    
34.     }
    & @. |8 K) {, L8 a1 c* G
35. 
    " }) _1 F6 @; a4 ^, e! _
36.     /* Disable ADC DMA transfer request during calibration */
    ! ]: e6 J: c7 @- M: m) R
37.     /* Note: Specificity of this STM32 serie: Calibration factor is           */
    - f7 H: A3 P; O1 u- q" m* @( m1 V
38.     /*       available in data register and also transfered by DMA.           */
    ) w  M2 [, v# x, u+ R2 g
39.     /*       To not insert ADC calibration factor among ADC conversion data   */
    
40.     /*       in DMA destination address, DMA transfer must be disabled during */
    
41.     /*       calibration.                                                     */
    
42.     backup_setting_adc_dma_transfer = LL_ADC_REG_GetDMATransfer(ADC1);
    + J/ M4 B5 s, D/ S8 L4 |* ]4 @
43.     LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
    $ v( c6 j% A5 ]7 c
44. 
    
45.     /* Run ADC self calibration */
    ! r$ Z  i" d1 H2 s, G  J. |; L4 n
46.     LL_ADC_StartCalibration(ADC1);
    " f% ^3 A8 U) i
47. 
    
48.     /* Poll for ADC effectively calibrated */
    $ i& D& s  T$ l- t
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    6 @5 ~% U( `5 X# A) n8 A* G: q. q
50. 
    
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    
52.     {
    9 g: y- e$ Z/ s1 G
53.       /* Check Systick counter flag to decrement the time-out value */
    
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    
56.         if(Timeout-- == 0)
    
57.         {
    . X+ t& ~/ I5 O9 J* l
58.                 return 0;
    
59.         }
    
60.       }
    
61.     }
    ; L0 L  C8 \. y& O7 y& G3 s% v! c
62. 
    * b$ L' Q. X# L8 [8 J& _  O
63.     /* Restore ADC DMA transfer request after calibration */
    
64.     LL_ADC_REG_SetDMATransfer(ADC1, backup_setting_adc_dma_transfer);
    : e8 G9 M, B3 L  r8 R9 w- O+ q
65. 
    
66.     /* Delay between ADC end of calibration and ADC enable.                   */
    " C$ E8 p7 c7 g5 A0 c
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)
    ; x5 C( @. ^# e/ v) d8 i. X
71.     {
    * N7 ]/ z5 h4 U" `% J
72.       wait_loop_index--;
    
73.     }
    
74. 
    , W# J/ n4 j$ J8 v% R' L. R0 U+ p
75.     /* Enable ADC */
    ' K6 Q0 m, ~& h0 q
76.     LL_ADC_Enable(ADC1);
    # Y) l0 H! m% W" {) u1 |
77. 
    0 \/ u5 @7 u9 {: E; x/ V. I
78.     /* Poll for ADC ready to convert */
    
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    . \# k/ a4 p! H& @# |/ n. N9 K
80. 
    5 N- y( U4 G+ d+ ]6 T$ u3 f
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    9 o9 Y& f3 T% m: H! r; a5 y, D
82.     {
    2 A% n8 Z; U0 B" H3 u( _+ B/ O
83.       /* Check Systick counter flag to decrement the time-out value */
    
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    & Z* _0 w+ n' y: t
85.       {
    
86.         if(Timeout-- == 0)
    
87.         {
    
88.                 return 0;
    
89.         }
    
90.       }
    ! X, F  O4 E% Y/ M; c
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    ! i) a9 C) P; c
93.     /*       status afterwards.                                               */
    ' P; B0 y7 L" b0 ?" U  X
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    4 j" d' ]+ L. U1 W
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    
96.   }
    + L8 T, S; w- h% U5 [2 G
97.   return 1;
    
98. }

复制代码

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

使能ADC采样：
+ U2 ~0 g; W- Y& ~
5 u8 j+ J, e+ [: A

1. uint8_t STM32ADC1SampleEnable(void)
   
2. {
   1 C( d- ^7 S7 N7 C
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   
5.     LL_ADC_Enable(ADC1);
   
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   
8.     {
   3 o3 u3 N9 h% z  r
9.           if(Timeout-- == 0)
   ) p( h. s- t  ?$ y$ [1 |
10.         {
    
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    7 X8 F- p9 L( c% v% N  }
12.                 return 0;
    
13.         }
      P7 G$ r$ l3 R( x
14.     }
    
15.     LL_ADC_REG_StartConversion(ADC1);
    + s/ Q: O5 I! H! \4 z/ t6 B
16.     return 1;
    6 t0 s0 E1 Y( P1 W
17. }

复制代码

( [! B( `' y: G& f2 h6 A' A失能ADC采样：
( U9 w! l/ Q) U2 Z
/ O) r. g3 ?4 o5 \" {

1. uint8_t STM32ADC1SampleDisable(void)
   
2. {
   
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   
4.     LL_ADC_REG_StopConversion(ADC1);
   % M! F: g8 q; G& V
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   # V- Q, X: L- @7 A+ G# c& p: x5 k
6.     {
   - y6 ?4 c( x7 U3 @( c
7.         if(Timeout-- == 0)
   4 N" b& e0 k" p" q/ F7 M: T
8.         {
   4 h7 A4 b2 S* T  v
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   9 A! N; h* B' _, S
10.             return 0;
    
11.         }
      u" ^7 K( @( c( M* r" U
12.     }
    
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    ' O* ^) {  Q# F) u/ G0 c
15.     return 1;
    
16. }

复制代码

. p" b. B  F2 X1 C" ?" a进行ADC数据采集流程（采用多次采样求平均值的方式）：

1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；

2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
8 P, [8 j% K( d- r& m2 W5 g$ \
0 p+ g5 Y' W& O/ E3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。
' @8 B/ l) G% K$ T6 A9 d7 ^/ P8 a
以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。


0 N/ w9 e7 }' n; m" C/ s) R! E( k, u