通过中断方式读取电压，不过最后楼主读取参考电压失败，还没有找到错误，所以读取的电压只能十六进制显示，

本文的介绍按照一般流程来走：
1，串口的初始化
2，ADC初始化
2 T* h# P5 c$ a3，中断初始化
  R: {! |# Q* O( x4，编写中断函数
5，编写主函数
' ^0 b. W: E9 j( y1 G
接下来详细介绍：

' u2 K$ m8 G6 b" j& c* J  @* V; Y1，串口的初始化：

1. void usart_init()
   7 t2 K  @# a8 z6 t
2. {
   
3.          GPIO_InitTypeDef Uart_A;  
   * D# w9 ]3 f: |% E6 x
4.       
   8 }8 r3 N6 ~/ ]7 g  v0 _0 O
5.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
   0 q" L" ~: {: g% N% a
6.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
   
7.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
   8 o9 [8 V! h8 h/ Q
8.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
   
9.     GPIO_Init(GPIOA,&Uart_A);  
   
10.       
    
11.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    " z, _+ m" I6 k  Y
12.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
13.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    ! a5 \: O1 S( ^8 q" W
14.     GPIO_Init(GPIOA,&Uart_A);   
    
15.        
    
16.         USART_InitTypeDef Uart;  
    ; k, m6 H+ I  g. [# Z
17.       
    
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    
19.     Uart.USART_BaudRate = 115200;  
    " {4 T! E$ h3 k- V. t3 k
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
21.     Uart.USART_Mode = USART_Mode_Tx;  
    
22.     Uart.USART_Parity = USART_Parity_No;  
    
23.     Uart.USART_StopBits = USART_StopBits_1;  
    
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    
25.     USART_Init(USART1,&Uart);  
    ! Z3 E" r" \. H4 L2 a
26.       
    
27.     USART_Cmd(USART1,ENABLE);  
    
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
      Z5 b( o" v5 @. L. [7 h
29. }

复制代码

关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。

$ h$ m5 Y* N* V$ \
2，ADC初始化
: `; [" U% a3 F3 B

1. typedef struct
   1 a  C& Y' a; s. D
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   - Q- {8 `- Y3 \% I% K1 c
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   , S( l0 O, B' S7 V9 ?; g+ e& y
4.                                                dual mode.
   
5.                                                This parameter can be a value of @ref ADC_mode */
   / A$ J0 A4 C; N5 c- J) _
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   * ?, o2 y" u# l) t5 [  U
8.                                                Scan (multichannels) or Single (one channel) mode.
   
9.                                                This parameter can be set to ENABLE or DISABLE */
   
10. //配置ADC是单次转换还是连续转换
    
11.   FunctionalState ADC_ContinuousConvMode; /*!< Specifies whether the conversion is performed in
    
12.                                                Continuous or Single mode.
    
13.                                                This parameter can be set to ENABLE or DISABLE. */
    ) @# G! ?, q) J6 Q
14. //外部触发选择
    / Z  m1 R  B; `" a2 Y
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    . k! R8 k; M- x3 L" V& |
16.                                                to digital conversion of regular channels. This parameter
    
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    7 C- w- s6 A* @5 ]
18. //转换结果数据对其方式
    
19.   uint32_t ADC_DataAlign;                 /*!< Specifies whether the ADC data alignment is left or right.
    
20.                                                This parameter can be a value of @ref ADC_data_align */
    2 j5 N( z- [5 j" K
21. //ADC转换的通道数目
    7 m: G( _8 ^# H8 v
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    
23.                                                using the sequencer for regular channel group.
    9 F6 K6 i* D8 P: W3 N2 g, ^
24.                                                This parameter must range from 1 to 16. */
    
25. }ADC_InitTypeDef;

复制代码

9 ]! w' `; ]5 t7 \- g5 z
8 b0 K/ A. `; r" G) Q下面粘贴代码：

1. void Adc_Init()
   " G+ d- k$ R; ]! j$ Z8 ~( c
2. {
   7 Y/ j+ R- l. x5 Q( \7 }
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
   ! G0 z# i' W) }% z
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   
5.        
   
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
   
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   & p0 |4 \$ d0 Z9 E6 ]$ m5 C
8.        
   ' R* W7 d( W2 p, ^
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   3 A& P) ?7 E# @. d6 L1 e9 x
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    & Q1 _- A5 K* q6 ~" O
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    * O# i7 k4 L" p  ~! k, a
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
      I( ?  |$ y% Z* n* Y
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    
16.         adc.ADC_ContinuousConvMode = ENABLE;使能连续扫描
    
17.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发
    * s0 u& [2 Y* h; A% ^- d
18.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据右对齐
    & u8 |$ E  r0 m0 S
19.         adc.ADC_NbrOfChannel = 2;来制定用几个ADC通达（勿忘）
    
20.         ADC_Init(ADC1,&adc);初始化ADC寄存器
    
21.        
    2 n1 k" ~3 L* C1 E) q. o
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    # K1 U/ A8 M) v4 h8 x' r9 {
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    , Q# [1 F: Q/ g3 q& _  _
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    4 k/ c3 ~7 v  D$ W) N
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    3 h1 E4 b- b- h' d7 `+ F0 T) I
29.        
    ( @2 |3 D: z8 R9 J$ E7 n% ?! E) ~
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    + t) }. W" O5 I- g" B9 i; T! u5 U
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    + m: F4 [3 e6 B. f$ A' r: I
33. }

复制代码

3.中断初始化
% e% j6 q; k) }

1. void adc_nvic_init()
   
2. {
   
3.        
   2 a* o* n0 _; h8 g6 k& ?
4.         NVIC_InitTypeDef nvic;定义中断结构体
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   % y7 v9 \7 u2 W7 F/ O7 L3 w- U
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   1 c# f0 l, O8 R" n- l" O
10.         NVIC_Init(&nvic);初始化
    
11.        
      W+ a# s% `5 o
12.         NVIC_InitTypeDef usart1;定义中断结构体
    9 I7 z8 J; M& M, x# n7 c
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    # n" [. }4 t8 o8 B6 B: U0 T
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    4 y* H# D' D2 M% `& L, c
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    : r& G6 j" U2 [8 a" x/ ^
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    6 p+ P* j; V) ^; k( x
18.         NVIC_Init(&usart1);中断初始化
    ! Q- |2 i: }  j, \# S
19. }

复制代码

7 I2 h4 @/ [5 o, c
4，编写中断函数
0 {2 `" K2 v' a' M# a7 f先粘贴代码：

1. void ADC1_2_IRQHandler()
   
2. {
   + |+ t$ Q7 T$ k0 Q- O; v9 e
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   : ?/ F4 N+ M! t5 q9 T, I. C
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   0 @. [  R* v2 Z( ?, a; M
6.                 count_1++;
   
7.         }else
   
8.                         {
   
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    
11.                                 count_1++;
    4 B& d, Z% l, X8 y- l
12.                         }
    
13.         }
    # `* k  J% J) A( R" x) e4 k4 X1 @
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    1 W8 k# }2 y: H$ W" U5 J
15. }
    
16. 
    
17. void USART1_IRQHandler(void)
    
18. {
    9 Q/ X) h, g. @, R. v# w
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    : T+ k3 n$ D8 S4 w5 f. R
20.         {
    ' X+ U7 D% p0 @8 R6 Q1 w2 q
21.                 USART1->CR1 &= ~USART_CR1_TXEIE;在这里笔者也碰到了问题，详见下文
    
22.                 USART1->DR = car;
    
23.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    
24.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
    3 O% L! Z: K: ?+ g0 w& T
25.         }
    ) M, }0 H, _0 t" N4 S  Z' p
26.        
    
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    , b- _6 b, H0 k1 n5 Y
28.         {
    * Y: |! y9 s6 F, x2 u) ^3 h
29.                 volatile int8_t com_data;
    
30.                 com_data = USART1->DR;
    
31.         }
    
32. }

复制代码

% R  j* W+ }. d7 s" F在ADC中断服务函数中，代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的，因为第一次接受的是外部电源电压，第二次接受的是内部参考电压，所以可以利用奇偶数，即偶数用ADC_ConvertedValue来存放外部电源电压值，奇数时用ADC_ConvertedValue_1来存放参考电压值。但是，笔者发现，这样会失败，经过串口调试发现两次接受到的值都一样，笔者初步认为，可能是ADC的转换速率太快了，具体什么歌情况还不清楚，等下一个基础设计ADC转换（DMA方式）的时候在细究。

  E& P1 t+ R8 g8 t+ Z, ?) [- F关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。
- m4 E( k$ C2 d: s
4 \+ ?) i, h. a3 t! Z" v---------------------------------------------------------------------------------------------------------------------------------

5，编写主函数

1. int main()
   ! X& _4 c8 O) c
2. {
   3 r: ^9 ~% k9 R: J$ I/ q
3.         void PrintU16(uint16_t num);
   
4.         void PrintHexU8(uint8_t data);
   & q  }0 v8 Z! N: L3 h+ |% F& [
5. 
   
6.         Adc_Init();
   
7.         adc_nvic_init();
   : o. ~. E' A: N: w: n
8.         usart_init();
   
9.         while(1)
   
10.         {
    
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    + Q! p3 ]9 x$ X
12.                 PrintU16(num);
    
13.                 delay(1000);
    
14.         }
    # v* ~: q& ~6 y" G9 J  b8 C& ?0 k
15. }

复制代码

& W: f. N2 _+ V: P/ }笔者并没有计算出准确的电压值，只是采集到两个电压值，笔者猜测，可能是因为ADC的转换速率太快，导致笔者的  通过奇偶数来区分内部电压和外部电压不管用了，笔者还在思考解决方式，如果读者有好的方法，请指教。
! g: K+ v( |2 S) f2 h) X* i
2 |, b$ M/ `& L% x, \$ L
本文到此结束，下面是完整代码：

1. #include<stm32f10x.h>
   2 {3 Q2 M6 C! j! J. ^1 [
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4.        
   
5. char car;
   
6. static char count_1=0;//当做奇偶数
   * ^  V- q; X$ j9 ]# T7 _
7. uint16_t ADC_ConvertedValue;//存放电源电压
   ) F  Y9 N+ {$ q3 M
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   
9.         static uint16_t num=0;
   ' Z4 m" N+ n3 x6 }
10. void delay(uint n)
    
11. {
    
12.         int i,j;
    
13.         for(i=0;i<n;i++)
    
14.         for(j=0;j<8500;j++);
    
15. }
    
16. 
    
17. void Adc_Init()
    
18. {
    ( y( c* }+ S& Y: B4 @
19.         ADC_InitTypeDef adc;
    8 k! a5 K2 ^+ f
20.         GPIO_InitTypeDef io_b;
    * h/ j1 _0 J, E& {: u6 |7 x- M
21.        
    7 T$ T: @. T0 E* p0 a* M
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    
24.        
    ) S. K# O. w4 f9 v8 d  W
25.         io_b.GPIO_Pin = GPIO_Pin_1;
    8 x3 p$ C+ }  Z+ E9 I: [0 L% `1 X
26.         io_b.GPIO_Mode = GPIO_Mode_AIN;
    
27.         io_b.GPIO_Speed = GPIO_Speed_50MHz;
    
28.         GPIO_Init(GPIOB,&io_b);
    
29.        
    8 j  ?% G$ b9 r# ?
30.         ADC_DeInit(ADC1);
    , I0 [9 U; p( A
31.         ADC_TempSensorVrefintCmd(ENABLE);
    % S; K8 V* d. z$ N; Q4 N
32.         adc.ADC_Mode = ADC_Mode_Independent;
    
33.         adc.ADC_ScanConvMode = ENABLE;
    3 F* G! E# s; E4 y( o: Y
34.         adc.ADC_ContinuousConvMode = ENABLE;
    
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    
37.         adc.ADC_NbrOfChannel = 2;
    
38.         ADC_Init(ADC1,&adc);
    
39.        
    + _* p& y! r8 N% t+ `& Q! m
40.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    
41.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    & E1 r( H) L, \% p6 t
42.        
    4 h, R4 w3 x  z) ?' i% g/ Q4 @9 W/ m; K
43.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);
    
44.         ADC_Cmd(ADC1,ENABLE);
    6 `0 c) b' L8 \+ q/ Q$ `
45.         ADC_ResetCalibration(ADC1);
    
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    3 ^3 o8 N. o5 W6 P5 ~4 \* I' v
47.        
    5 l: a, ~" b) l8 e0 ^
48.         ADC_StartCalibration(ADC1);
    7 N6 H  ^1 I* B0 R% h
49.         while(ADC_GetCalibrationStatus(ADC1));
    ) ^/ Q& _! O' @( F/ c2 [, G$ k0 V$ u
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    5 v& e' ^- a0 a
51. }
    9 _2 F& J9 L4 ?, \
52. 
    & I& R/ b  S; u( c$ r0 @
53. void adc_nvic_init()
    9 z9 V7 p* D8 q, v7 o7 G- {
54. {
    - s& x$ N7 K  P8 m0 b7 b4 Q
55.        
    1 F0 n% Z( S5 G4 n5 n
56.         NVIC_InitTypeDef nvic;
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    " q0 O" I3 q! c  p- a
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    ! L! d6 c1 x7 R, \4 I  W2 [
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    , t4 [& T" U! S' J" v
62.         NVIC_Init(&nvic);
    
63.        
    
64.         NVIC_InitTypeDef usart1;
    # L" @; [2 B! R, e# w' h
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    5 H$ d0 Q5 s3 |  W8 ~" E
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    8 x9 Q2 I! |' l2 q0 C
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    : W& W' t1 O. @0 H# I, p9 L
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    $ ~- J8 i6 c0 A" k1 L
70.         NVIC_Init(&usart1);
    
71. }
    
72. 
    6 v( B. n; D2 q, R3 f
73. void usart_init()
    . i) D, F3 c: \- q9 j, B
74. {
    
75.          GPIO_InitTypeDef Uart_A;  
    ' j5 w. m  H; f. E. M) |" S
76.       
    * b" j+ Y5 `% h) q  F5 ?( ~
77.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
    
78.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
    
79.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
80.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
    & E; \. V- W$ e
81.     GPIO_Init(GPIOA,&Uart_A);  
    
82.       
    
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
86.     GPIO_Init(GPIOA,&Uart_A);   
    9 G* {6 G! _& F$ T" l% j  |' S+ Z# p  B
87.        
    9 Q2 U. T) A9 K) h7 |# T4 j
88.         USART_InitTypeDef Uart;  
    / d, f( R0 O6 @# q. i! f
89.       
    
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    4 q! R4 W! I( T6 W, \3 h! h1 W
91.     Uart.USART_BaudRate = 115200;  
    $ _0 J% Q/ _# ^: X0 ~; T( E" t
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
93.     Uart.USART_Mode = USART_Mode_Tx;  
    2 y* s8 h3 }* W5 |
94.     Uart.USART_Parity = USART_Parity_No;  
    : }7 }6 R- T& _; w+ y
95.     Uart.USART_StopBits = USART_StopBits_1;  
    4 P! y% k/ b( a2 I' y
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    1 F8 k7 h$ G% Q+ b" E
97.     USART_Init(USART1,&Uart);  
    5 i( C4 M6 q. I( ~0 g. x7 a
98.       
    # J- J* b7 r- d" i1 C
99.     USART_Cmd(USART1,ENABLE);  
      G' {/ j  T$ C4 V' v
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     + L2 Y: A$ c8 C5 f9 k' b6 F! `3 Z- j
101. }
     
102. int main()
     + y) P# Y1 r# G8 E) s
103. {
     5 A  W. e1 I  d* f9 `/ ]" Y
104.         void PrintU16(uint16_t num);
     
105.         void PrintHexU8(uint8_t data);
     
106. 
     / v. Z; C2 |6 k9 G3 n0 S
107.         Adc_Init();
     ( f+ z* y- q: |; W/ e6 |0 O7 \& Y
108.         adc_nvic_init();
     & b' P3 I# Z$ ]0 }. v$ R
109.         usart_init();
     
110.         while(1)
     
111.         {
     
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     
113. 
     
114.                 PrintU16(num);
     ! _% x: G0 n! W' \
115.                 delay(1000);
     
116.         }
     
117. }
     ) U9 Q* q6 ]# G  v
118. 
     0 T$ _+ j' C9 V( N1 m* q+ D7 l3 s% I
119. void PrintU16(uint16_t num)
     - E% r3 N3 i7 W% }) x5 ~% \
120. {
     
121.         void PrintHexU8(uint8_t data);
     3 L2 ?+ Z+ x& z  i; S
122.         uint8_t w5,w4,w3,w2,w1;
       K& h; n+ }+ f: H5 I' x9 U
123.         w5 = num % 100000/10000;
     & }9 r2 ?# f% b8 r6 z- G) \
124.         w4 = num % 10000/1000;
     : v. F: c' L$ n8 H
125.         w3 = num % 1000/100;
     4 w! J' Y# M1 T% h5 l4 A6 `
126.         w2 = num % 100/10;
     
127.         w1 = num % 10;
     
128.         PrintHexU8('0' + w5);
     
129.         PrintHexU8('0' + w4);
     
130.         PrintHexU8('0' + w3);
     
131.         PrintHexU8('0' + w2);
     ! |9 A& {; \! p( n+ j. x6 ^. Y* V
132.         PrintHexU8('0' + w1);
     ( ?( ?3 @2 M8 ?! j7 X
133. }
     
134. 
     % B+ g4 N" y; U% b
135. void PrintHexU8(uint8_t data)
     
136. {
     : ^  h' ~% q9 ]5 ^, U
137.         car = data;
     
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     2 u! u. u. N7 K9 d* ]: Y6 z/ N
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     
140. }
     
141. 
     
142. void ADC1_2_IRQHandler()
     & |4 ~6 K/ a1 a( o
143. {
     
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     
145.         {if(count_1%2 == 0){
     $ l( E2 s  @' D1 ?5 l9 ]' s
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     
148.         }else
     
149.                         {
     
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     ) F9 h9 L" h3 P
151.                                 count_1++;
       X0 |7 N& r3 G9 `
152.                         }
       a9 A7 P, g3 @6 [) n
153.         }
     7 W  U! p+ d* i* ~
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     
155. }
     9 Q3 i/ q, Y- p, u- u
156. 
     ( Z' H) `. a6 H( }0 t, t
157. void USART1_IRQHandler(void)
     * a% n- P! O. G% n' E% A
158. {
     
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     1 v2 f9 b) J1 z
160.         {
     
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     " D9 B: Q  C$ [4 l* b* F% U
162.                 USART1->DR = car;
     7 p8 v- V# e8 o6 @6 ?  a
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     5 e" G$ b" ?# a& b$ g
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
     
165.         }
     
166.        
     8 A8 ?8 R! u& k, o6 c8 r# ~
167.         if(USART1->SR & USART_SR_RXNE)
     
168.         {
     6 c9 C8 s# d# n" @/ ^
169.                 volatile int8_t com_data;
     
170.                 com_data = USART1->DR;
     / `1 l  k- R% I& B: b
171.         }
     0 |8 ~/ w! G. x7 p4 N
172. }

复制代码

. _; v8 M) l9 U3 w! t. t* V; C————————————————
0 W0 S- _% J- ]版权声明：家安
& [5 I! D- b3 ^  S2 l  Q4 l& D  s
& R- K% [* C- s. E: n8 b1 @
) u" e* c- ^1 O9 T