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

) A' w" q! e: o8 A  A; d: M6 G7 jADC的初始化：
& @! \: z& W% i. X' X
- E: f, d! g, t1 H, |, H. {

1. #define ADCIO1_IN_CHANNEL           LL_ADC_CHANNEL_5
   
2. #define ADCIO2_IN_CHANNEL           LL_ADC_CHANNEL_7
   4 ?+ T* q/ ^# |7 B3 `+ N3 N
3. uint8_t STM32LLADC1Init(void)
   
4. {
   ' U+ ~6 b1 g; D6 ]9 O
5.   LL_ADC_REG_InitTypeDef ADC_REG_InitStruct = {0};
   
6.   LL_ADC_InitTypeDef ADC_InitStruct = {0};
   ; d+ N0 I$ f1 x' k, {  d# T
7. 
   
8.   LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
   
9. 
   
10.   /* Peripheral clock enable */
    
11.   LL_APB2_GRP1_EnableClock(LL_APB2_GRP1_PERIPH_ADC);                //使能ADC时钟
    3 `; R2 x/ L- m; N8 e& B& l
12. 
    
13.   LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);                //谁能响应ADCioGpio时钟
    
14.   /**ADC1 GPIO Configuration  
    # q; L# h0 o) `( g) B& M2 w
15.   PA5   ------> ADC1_IN5
    
16.   PA7   ------> ADC1_IN7
    2 b; ]3 q5 Y) w* j) e6 s* V; F
17.   */
    ( Y2 V7 F( v1 {( T. [6 p
18.   GPIO_InitStruct.Pin = gpioADCIO1_IN_PIN;                            //ADC检测IO初始化
    # r2 U) \! H1 j3 j5 \
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;
    
24.   GPIO_InitStruct.Mode = LL_GPIO_MODE_ANALOG;
    ( V, \. f% d: {# u* @
25.   GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
    ! X, N0 z9 J0 ~1 h2 m: H$ a
26.   LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
27. 
    
28. 
    
29.   /** Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
    
30.   */
    
31.   ADC_REG_InitStruct.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE;                //ADC定时转化触发条件来源，可以为软件触发或硬件（外部中断、定时器）触发。
    - L, ~2 V; x1 O8 `% ~
32.   ADC_REG_InitStruct.SequencerLength = LL_ADC_REG_SEQ_SCAN_ENABLE_2RANKS;     //ADC顺序采集通道的个数，根据自己需要的通道个数设置
    0 O) E% G7 x% O1 _  S
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);
    + J# j  C7 E3 V- R8 o0 q
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使用时不是连续的，所以这里使用可自定义配置
    
41.   LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_COMMON_1,     LL_ADC_SAMPLINGTIME_160CYCLES_5);    //设置通道共用取样时间，根据需要自行选择
    8 c0 H8 X" t- m; X1 Y3 @& v9 I
42.   LL_ADC_DisableIT_EOC(ADC1);        //禁用通道采样结束中断
    + w, B: F; K9 X9 |* Z0 N1 K: Z
43.   LL_ADC_DisableIT_EOS(ADC1);        //禁用序列采样结束中断，因为使用的是单次软件触发所以这里关闭这些中断
    0 z; x3 ]  ^* {; [% ?. J" e/ h1 N/ g$ b
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的话无法使用，这里关闭
    
48.   LL_ADC_Init(ADC1, &ADC_InitStruct);
    # p* R9 R6 K3 Y$ X* |& z
49.   /** Configure Regular Channel
    
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); //设置通道采样时间
    4 Y0 Z2 P  O+ |# f
54.   LL_ADC_REG_SetSequencerRanks(ADC1, LL_ADC_REG_RANK_2, ADCIO2_IN_CHANNEL);                //将硬件通道ADCIO1_IN_CHANNEL映射到ADC通道2
    / Q6 R# s/ t+ O; V7 H% _2 E9 P' g& t3 d
55.   LL_ADC_SetChannelSamplingTime(ADC1, ADCIO2_IN_CHANNEL, LL_ADC_SAMPLINGTIME_COMMON_1);  //设置通道采样时间
    
56. 
    
57.   /*采样数据转换时需要参考电压，参考电压可能是变化的，所以也有可能需要采集*/
    7 @/ V7 q( O* ~7 P" K! B7 V
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);
    ' D2 _5 t& W* ~1 a/ E
60. return 1;
    " J7 m) t  A8 L9 J
61. }

复制代码

+ j6 z' d, e% c+ I+ ~4 k激活并校准ADC：

1. uint8_t STM32ActivateADC1(void)
   
2. {
   # R  I* Y, A, H( j
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 #####################*/
   + n: l9 w1 W5 I' {) X, r1 q1 D
7. 
   
8.   /* Note: Hardware constraint (refer to description of the functions         */
   
9.   /*       below):                                                            */
   6 F0 w5 _; ^# b$ r4 Q6 c) ?
10.   /*       On this STM32 serie, setting of these features is conditioned to   */
    / B0 y. T+ B. _7 G; g% h
11.   /*       ADC state:                                                         */
    
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                */
    6 u* A. [. O/ c% z  p  U  ?
15.   /*       corresponding to reference manual procedure.                       */
    0 e2 M! A9 a( T$ T7 u
16.   /*       Software can be optimized by removing some of these checks, if     */
    
17.   /*       they are not relevant considering previous settings and actions    */
    . r' p; j- |6 x  e8 G7 u
18.   /*       in user application.                                               */
    - z# p* ~) Y3 l: |9 R$ p
19.   if (LL_ADC_IsEnabled(ADC1) == 0)
    
20.   {
    
21.     /* Enable ADC internal voltage regulator */
    & B. q4 p5 w/ T
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.                             */
    . [. m, i) g0 P1 I
30.     wait_loop_index = ((LL_ADC_DELAY_INTERNAL_REGUL_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
    : q: G! W" A  i+ [- I4 F$ }1 D3 ~6 a
31.     while(wait_loop_index != 0)
    . I* @( N* ~! H
32.     {
    , J+ @+ U1 h2 O: V: U3 T
33.       wait_loop_index--;
    ! E3 y- s: B1 Q6 x( `& F. W
34.     }
    
35. 
    
36.     /* Disable ADC DMA transfer request during calibration */
    
37.     /* Note: Specificity of this STM32 serie: Calibration factor is           */
      x$ x( z1 Y% g" M5 m
38.     /*       available in data register and also transfered by DMA.           */
    4 C( U2 x# P* W, n2 _3 }1 H
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);
    3 I3 s6 a) p: p' S) \! v" R# y) O
43.     LL_ADC_REG_SetDMATransfer(ADC1, LL_ADC_REG_DMA_TRANSFER_NONE);
      ]* x! h" o3 U  ~
44. 
    
45.     /* Run ADC self calibration */
    6 s% ]  n; j; u- M3 P2 S+ d' m  X4 m2 B
46.     LL_ADC_StartCalibration(ADC1);
    2 U8 S, I4 I1 s0 B: c
47. 
    1 P' k* g6 l# h7 ^4 g
48.     /* Poll for ADC effectively calibrated */
    
49.     Timeout = ADC_CALIBRATION_TIMEOUT_MS;
    , p) D: Y0 b9 c; y, r9 z& v, r
50. 
    
51.     while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0)
    
52.     {
    & f. H1 p' \; W# p( x7 A/ E/ h* Q
53.       /* Check Systick counter flag to decrement the time-out value */
    # ~3 R% X- s7 l4 y; p: }' H' i
54.       if (LL_SYSTICK_IsActiveCounterFlag())
    
55.       {
    
56.         if(Timeout-- == 0)
    
57.         {
    
58.                 return 0;
    ' {% Q; Z# b1 _1 K+ a, o; |
59.         }
    : J, O# ^& P9 J$ W: a9 y( v% y
60.       }
    2 Z4 G9 c7 v  Z/ L! ~4 e- J! H
61.     }
    4 U0 N  A/ b6 z  z4 S+ X: s
62. 
    
63.     /* Restore ADC DMA transfer request after calibration */
    + Y# m2 x7 ?9 I8 t
64.     LL_ADC_REG_SetDMATransfer(ADC1, backup_setting_adc_dma_transfer);
    ) z$ T& B% H# R  z7 x  G: W, G% O; V: e
65. 
    
66.     /* Delay between ADC end of calibration and ADC enable.                   */
    : w. \6 Z& k& P# z
67.     /* Note: Variable divided by 2 to compensate partially                    */
    
68.     /*       CPU processing cycles (depends on compilation optimization).     */
    ( y* \) F" p: {  U
69.     wait_loop_index = (ADC_DELAY_CALIB_ENABLE_CPU_CYCLES >> 1);
    
70.     while(wait_loop_index != 0)
    1 E/ W+ J/ w) J9 A9 X: v" A
71.     {
    
72.       wait_loop_index--;
    
73.     }
    
74. 
    . S# e' b/ X# T6 C0 e
75.     /* Enable ADC */
    $ p% h3 z  D. M4 c2 {  t
76.     LL_ADC_Enable(ADC1);
    
77. 
    
78.     /* Poll for ADC ready to convert */
    3 f0 L9 q7 _6 y3 Q8 M
79.     Timeout = ADC_ENABLE_TIMEOUT_MS;
    
80. 
    
81.     while (LL_ADC_IsActiveFlag_ADRDY(ADC1) == 0)
    
82.     {
    / W4 C+ d( {' T- K
83.       /* Check Systick counter flag to decrement the time-out value */
    
84.       if (LL_SYSTICK_IsActiveCounterFlag())
    ( i9 o6 O) h% k! n) X4 R& }
85.       {
    
86.         if(Timeout-- == 0)
    
87.         {
    
88.                 return 0;
    ' O+ G3 r  ]$ X, w) J- L" o" _
89.         }
    
90.       }
    
91.     }
    
92.     /* Note: ADC flag ADRDY is not cleared here to be able to check ADC       */
    " p3 O$ q7 u/ |' M. L, r& @
93.     /*       status afterwards.                                               */
      A) A0 k4 T9 {" E! S1 f$ _
94.     /*       This flag should be cleared at ADC Deactivation, before a new    */
    
95.     /*       ADC activation, using function "LL_ADC_ClearFlag_ADRDY()".       */
    6 S/ e: O: l+ E! t# G
96.   }
    $ E/ R3 v$ v2 R/ e: m% T- N
97.   return 1;
    1 h$ t% B& A. g, F" s1 E8 \8 I$ |
98. }

复制代码

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

使能ADC采样：
' r" f1 v5 v) P/ q) f3 ]

1. uint8_t STM32ADC1SampleEnable(void)
   
2. {
   
3.     uint32_t Timeout = ADC_ENABLE_TIMEOUT_MS;
   5 d" M3 e! U) R( Y" o$ U5 l
4.     LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);            //先使能dma再使能adc，以防采样数据丢失
   $ @( w8 O+ \* L# c+ |4 d7 F
5.     LL_ADC_Enable(ADC1);
   2 z# D, P% j% F  H, m9 \7 Q" [
6.     Timeout = ADC_ENABLE_TIMEOUT_MS;
   5 Q4 W" h; s( b2 E& l6 F
7.     while(LL_ADC_IsActiveFlag_ADRDY(ADC1) != SET)
   " _% l, z- o$ e& }
8.     {
   
9.           if(Timeout-- == 0)
   
10.         {
    * K# l) B5 g2 e
11.            LOG(1,"STM32ADC1SampleEnable ERROR!!!");
    
12.                 return 0;
    
13.         }
    ' u5 D! t5 l6 }1 `7 @5 p+ @
14.     }
    ! ^$ b; T2 u% U- f# B" F
15.     LL_ADC_REG_StartConversion(ADC1);
    
16.     return 1;
    
17. }

复制代码

+ W  W  ?# |$ u- p& t5 |失能ADC采样：
2 c6 J+ X2 Z" o
0 d) M2 `: b3 T2 w2 ]  B% m2 {

1. uint8_t STM32ADC1SampleDisable(void)
   " E  [3 W1 F2 d! {; ?( [1 x
2. {
   0 U: U4 {/ d. S8 H* M; q3 }
3.     uint32_t Timeout = ADC_DISABLE_TIMEOUT_MS;
   & o* C" a- F0 f( v
4.     LL_ADC_REG_StopConversion(ADC1);
   ( K, x- R0 s# J& n2 N+ F
5.     while(LL_ADC_REG_IsConversionOngoing(ADC1) != 0)
   . H+ K* K- ?; t8 O
6.     {
   : I# S' ^8 Q% T+ I0 G3 ?5 W1 @
7.         if(Timeout-- == 0)
   , ]7 n" H4 @* Q7 p0 f
8.         {
   - F; l( L2 y* A( ?5 g1 W# Z  K. H
9.             LOG(1,"STM32ADC1SampleDisenable ERROR!!!");
   
10.             return 0;
    
11.         }
    / ?$ t1 w2 j, W6 S* |
12.     }
    5 H7 K3 m! M% d/ {8 R
13.     LL_ADC_Disable(ADC1);                            //先关闭adc再断开dma，以防采样数据丢失
    * n( ^% C1 Y( F( z7 L
14.     LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
    * Y/ j, v0 Z6 H" P/ [$ g# w3 b& r
15.     return 1;
    
16. }

复制代码

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

  j& R9 h$ [) T) V+ M1、当需要开始采样前，调用一次STM32ADC1SampleEnable()函数；
. Y3 P9 h* \+ c. \  }: O1 A
7 [3 T6 P0 N  n4 l- P6 W( t2、在一个定时函数内调用LL_ADC_REG_StartConversion(ADC1)进行数据的转换（因为使用的是单次采样，所以每次进入定时函数时都需要调用），取出DMA数据进行累加；
* _: @+ k0 N6 }
3、达到需要的采样次数之后，对得到的数据进行运算，并调用STM32ADC1SampleDisable()函数关闭ADC通道。
/ i3 J' V8 R. S% A, y6 X
0 P' w, K2 {7 V* p& B4 O6 Z以上方式适用于需要间隔一段时间获取一次ADC数据时使用，例如需要每隔1分钟获取电池电压时，可以进行1分钟倒计时，然后连续进行十次间隔10ms的ADC采样求平均值。
6 E' b" d1 z# d" L