通过中断方式读取电压，不过最后楼主读取参考电压失败，还没有找到错误，所以读取的电压只能十六进制显示，
% A) B, D7 ]- L! M
本文的介绍按照一般流程来走：
1，串口的初始化
% c, U  k7 x" P$ B$ Z& r- c2，ADC初始化
2 v+ |7 z) F" N3，中断初始化
4，编写中断函数
5，编写主函数
% q$ ^/ |2 C. n
接下来详细介绍：
4 L9 _8 ^! h* _
$ e8 j+ @# B/ p7 j1，串口的初始化：

1. void usart_init()
   
2. {
   # ]8 C) Y9 G9 u. j
3.          GPIO_InitTypeDef Uart_A;  
   
4.       
   - G/ x& i& [8 |; h6 B9 f
5.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
   
6.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
   
7.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
   
8.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
   ' R- R" M4 p- \
9.     GPIO_Init(GPIOA,&Uart_A);  
   
10.       
    
11.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    3 x, Y5 p: g/ }; q7 S
12.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
13.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
14.     GPIO_Init(GPIOA,&Uart_A);   
    
15.        
    0 p) |, A0 I) B0 r0 `
16.         USART_InitTypeDef Uart;  
    : @" b( M8 ~  ~- v
17.       
    1 f4 X9 O& e/ b) ]8 [2 ]; U, B
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    9 X1 j- y; j; o! a2 \' Q
19.     Uart.USART_BaudRate = 115200;  
    - l6 q* v: I* K7 A8 s3 l
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    . s- N3 |0 A, j- I
21.     Uart.USART_Mode = USART_Mode_Tx;  
    
22.     Uart.USART_Parity = USART_Parity_No;  
    
23.     Uart.USART_StopBits = USART_StopBits_1;  
    8 X1 v3 {& e- r$ R* c# v
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    
25.     USART_Init(USART1,&Uart);  
    
26.       
    
27.     USART_Cmd(USART1,ENABLE);  
    
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
    & @3 Y* l2 U% v: e5 [3 L
29. }

复制代码

关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。
) ^0 i5 C: i( i' X' b# ?
1 C- X+ O, W, @' H
0 ^3 @' E& ^! t2，ADC初始化
5 l/ R. N% _) @+ |

1. typedef struct
   
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   + T& i* g8 w& D' h6 |9 w
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   ( V1 \! u' f8 ?
4.                                                dual mode.
   ; f: O/ f# {% }1 m2 z: u+ C2 ~
5.                                                This parameter can be a value of @ref ADC_mode */
   
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   3 P$ M5 ~% E5 ^+ K/ }! ?/ E
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   0 R4 y; ]- j1 }9 S! F: y( u! c
8.                                                Scan (multichannels) or Single (one channel) mode.
   - A8 ~6 k: o9 n2 B# O3 m3 Y
9.                                                This parameter can be set to ENABLE or DISABLE */
   
10. //配置ADC是单次转换还是连续转换
    # \; \0 r7 s1 ]5 O( [7 O
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. */
    
14. //外部触发选择
    + r6 }7 p+ z; p/ O' B5 m
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    
16.                                                to digital conversion of regular channels. This parameter
    
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    / l3 l( n# y* Z/ M' ~) L* F$ ]
18. //转换结果数据对其方式
    # ^4 T* w% Q* }! Q) m
19.   uint32_t ADC_DataAlign;                 /*!< Specifies whether the ADC data alignment is left or right.
    3 a8 M: ]# S( A4 n
20.                                                This parameter can be a value of @ref ADC_data_align */
    7 ?# n  ]  X$ H. d6 _5 C( [
21. //ADC转换的通道数目
    ! ~3 I4 T  @4 E5 e
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    
23.                                                using the sequencer for regular channel group.
    
24.                                                This parameter must range from 1 to 16. */
    - b5 j& j% ?0 T4 W( J
25. }ADC_InitTypeDef;

复制代码

下面粘贴代码：
5 O* h/ v, g4 D8 g: s' s

1. void Adc_Init()
   
2. {
   
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
   5 X$ y9 @) N6 P2 w7 c2 s
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   
5.        
   5 s5 P$ o$ X, h
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
   : z! D; q  D; k" R
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   ! B0 n. w, ~5 u- @1 a8 e
8.        
   
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   ' Q1 f9 v& T* R( Y: E6 K  n
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    , u4 h, _% }: Z6 o: Y8 F& q$ T
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    8 z( a. b4 m/ k$ j" f" x
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
    8 G, G! k7 S  ~
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    3 d9 T$ n+ h8 K! Y4 R( l) {  j: x' D
16.         adc.ADC_ContinuousConvMode = ENABLE;使能连续扫描
    
17.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发
    
18.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据右对齐
    
19.         adc.ADC_NbrOfChannel = 2;来制定用几个ADC通达（勿忘）
    
20.         ADC_Init(ADC1,&adc);初始化ADC寄存器
    
21.        
    3 E) J; d2 h2 y0 k# k7 G: ]2 B3 {
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    5 j# L! w( Y' a+ F+ |3 g  v+ _6 y
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    & U, s+ E. Q$ f' f5 l6 ]
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    : O% Q+ R, V$ A6 h8 Y2 l3 i
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    4 z: S$ A' s! X$ D. T' O6 W
29.        
    " G2 W$ g: v: x- N6 S4 V9 h  Q
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    : P- |  |6 Y; r
33. }

复制代码

3.中断初始化

1. void adc_nvic_init()
   8 b7 I9 ~) _. v) U: |
2. {
   
3.        
   : k* ]7 x' Y3 Z. L
4.         NVIC_InitTypeDef nvic;定义中断结构体
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   9 l; ]& C* p8 D/ w9 _0 }
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   " Y3 M" a: X$ f
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   , L" V; z$ p/ }  }. @6 u2 o
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   % l# ~" _( r+ L! t4 x% w# t
10.         NVIC_Init(&nvic);初始化
    
11.        
    7 F# z) a+ j1 T) ?0 i& g8 q
12.         NVIC_InitTypeDef usart1;定义中断结构体
    
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    ; J$ |) _8 ~, l+ A
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    
18.         NVIC_Init(&usart1);中断初始化
    
19. }

复制代码

% D# J9 }( G9 ?2 X8 @' {1 ~) t4，编写中断函数
先粘贴代码：

1. void ADC1_2_IRQHandler()
   
2. {
   
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   7 ]! u6 B. f# q, X4 }3 r& T
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   $ H4 p; f! |3 j5 C& [; h' b" d
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   
6.                 count_1++;
     j) E% N  F, V  X/ p& Y6 F$ y
7.         }else
   
8.                         {
   
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    6 E  h! V: F1 |, t4 N/ `3 ?
11.                                 count_1++;
    - L9 o8 w9 C+ `6 {1 v! g# u
12.                         }
    : _) B5 D; l; M4 l% D* t
13.         }
    
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    
15. }
    " {( ~0 B' {# g% V
16. 
    
17. void USART1_IRQHandler(void)
    
18. {
    , D3 M2 ?, u- r9 ^5 m' ?
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    
20.         {
    - F7 O# u. a1 b2 Y& ]1 Y% S6 C1 O
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;
    1 z* T1 h0 w6 e9 I- t) T3 W
25.         }
    
26.        
    9 a/ q6 O: ~2 e
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    
28.         {
    5 ^1 K. b2 W9 ~; x  Y4 P
29.                 volatile int8_t com_data;
    
30.                 com_data = USART1->DR;
    
31.         }
    
32. }

复制代码

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

关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。
) Y( h0 J4 [3 \2 N
---------------------------------------------------------------------------------------------------------------------------------
; X9 F2 n) k/ P. R8 G, r
' _  v8 p7 b) j8 e( N5，编写主函数

1. int main()
   ; k2 F/ [( {7 k  H- X3 Z' r
2. {
   + v  U4 C6 q1 ^; k3 P. s
3.         void PrintU16(uint16_t num);
   4 F' ^& P2 r: L' t- P) N3 k
4.         void PrintHexU8(uint8_t data);
   2 ]  A& d/ c" L. q
5. 
   
6.         Adc_Init();
   2 h* @( \2 o* v6 A. y
7.         adc_nvic_init();
   6 M( i" y  d2 F' u: T$ W2 D
8.         usart_init();
   
9.         while(1)
   ; o% t8 ?/ g9 N3 P6 V0 D& g! H. K
10.         {
    4 G+ j4 u% G, F+ R
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    / s0 U* Z8 g8 V9 _  i& w, {* P
12.                 PrintU16(num);
    " P; ]$ n# Z( I
13.                 delay(1000);
    ' C" b9 S1 s) y0 a1 ?
14.         }
    
15. }

复制代码

; F1 Q  z. t3 A" |2 c1 ~, |" a! c1 c
笔者并没有计算出准确的电压值，只是采集到两个电压值，笔者猜测，可能是因为ADC的转换速率太快，导致笔者的  通过奇偶数来区分内部电压和外部电压不管用了，笔者还在思考解决方式，如果读者有好的方法，请指教。


本文到此结束，下面是完整代码：

: H( @. F) h- R

1. #include<stm32f10x.h>
   $ A- l( m* m9 n8 u. C
2. #define uint unsigned int
   9 k% A* L1 v, Q) C0 l+ h
3. #define uchar unsigned char
   
4.        
   
5. char car;
   9 n7 w# Q3 A4 v) k) ^
6. static char count_1=0;//当做奇偶数
   
7. uint16_t ADC_ConvertedValue;//存放电源电压
   9 @0 U- A* n! h) p1 N  ?3 ]& W
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   + ]& ]  m( b1 l  z3 n
9.         static uint16_t num=0;
   
10. void delay(uint n)
    
11. {
    $ K. R. d/ S: D: K" k
12.         int i,j;
    ; g1 K3 q5 ~* K( J
13.         for(i=0;i<n;i++)
    
14.         for(j=0;j<8500;j++);
    9 z  q) T8 q* |
15. }
    8 }0 `1 B" e( V- V# W: \" U
16. 
    & l5 m7 m. ]; ^$ Y2 A, m/ u
17. void Adc_Init()
    
18. {
    " h: G- _3 e7 i2 d/ a& }, H' M
19.         ADC_InitTypeDef adc;
    
20.         GPIO_InitTypeDef io_b;
    
21.        
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    / b0 A* L" v& g4 v% S, F0 c
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    $ b) j$ Y. u6 B) j& H
24.        
    
25.         io_b.GPIO_Pin = GPIO_Pin_1;
    ! @9 u0 z/ G9 K; C8 r
26.         io_b.GPIO_Mode = GPIO_Mode_AIN;
    ; ]3 V9 p/ z0 E3 @# k
27.         io_b.GPIO_Speed = GPIO_Speed_50MHz;
    : g+ O* `" e; c
28.         GPIO_Init(GPIOB,&io_b);
    
29.        
    
30.         ADC_DeInit(ADC1);
    
31.         ADC_TempSensorVrefintCmd(ENABLE);
    
32.         adc.ADC_Mode = ADC_Mode_Independent;
    4 A5 H$ u* v% C/ O5 X# Q
33.         adc.ADC_ScanConvMode = ENABLE;
    , p+ l' Z2 y! ~! q( K' `
34.         adc.ADC_ContinuousConvMode = ENABLE;
    3 \# I6 L3 i. A2 ^
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    6 x/ r. Q: d  P1 _, B) j: ~
37.         adc.ADC_NbrOfChannel = 2;
    
38.         ADC_Init(ADC1,&adc);
    : y, p* X( Q  s0 |
39.        
    0 h3 F9 }9 Y7 R4 R5 P- q8 e  h
40.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    
41.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
42.        
    
43.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);
    
44.         ADC_Cmd(ADC1,ENABLE);
    : A5 y! ?9 }5 Y  A+ n  N
45.         ADC_ResetCalibration(ADC1);
    
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    
47.        
    
48.         ADC_StartCalibration(ADC1);
    
49.         while(ADC_GetCalibrationStatus(ADC1));
    
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    4 z* M$ j' f9 k$ J/ K, G6 E" y
51. }
    $ R+ d! U! w( M
52. 
    
53. void adc_nvic_init()
    " d# R# N, x1 ?: x( J' o  a
54. {
    
55.        
    
56.         NVIC_InitTypeDef nvic;
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    , x! R4 j1 x' X& ]7 {9 S
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    2 R" u! c2 o3 ~, ^
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    % t/ q' E  h/ ?8 {4 P- k6 V, Z5 _
62.         NVIC_Init(&nvic);
    + w- p% t& ~% u; {
63.        
    , p& a: t9 o) x; c
64.         NVIC_InitTypeDef usart1;
    " Q, V1 e; x: V  K1 O' V
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    % Z6 [# }/ A3 F  [# f
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    3 R; @7 }: y% }) t" D+ F
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    ' W+ w: R& K, J2 A
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    
70.         NVIC_Init(&usart1);
    0 r+ n: D7 f* ^
71. }
    : o. W  L* {% d7 ~) m
72. 
    
73. void usart_init()
    : H  t  A- I1 o2 l
74. {
    
75.          GPIO_InitTypeDef Uart_A;  
    
76.       
    / K, b8 z6 k" M6 Z' B1 T, y/ ?  N
77.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
    
78.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
    
79.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    0 q- U0 |. u4 ]5 |
80.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
    ' O' g" O& S! H0 o: O
81.     GPIO_Init(GPIOA,&Uart_A);  
    
82.       
    
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    % I+ t4 L) B( n
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    * f" K$ a9 r7 z1 k) a
86.     GPIO_Init(GPIOA,&Uart_A);   
    8 O1 L* a" @4 G
87.        
    1 X: U* a  q( v
88.         USART_InitTypeDef Uart;  
    : @3 t- p8 v2 a2 v
89.       
    # P# Z6 _7 e5 c+ S- w4 b' j0 D
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    
91.     Uart.USART_BaudRate = 115200;  
    
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
93.     Uart.USART_Mode = USART_Mode_Tx;  
    
94.     Uart.USART_Parity = USART_Parity_No;  
    2 ~: o& t) u2 y2 T
95.     Uart.USART_StopBits = USART_StopBits_1;  
    # s* k5 A4 B# z9 i
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    0 N5 W* P/ _; _5 z0 A
97.     USART_Init(USART1,&Uart);  
    
98.       
    
99.     USART_Cmd(USART1,ENABLE);  
    + t9 r# h4 {! u' w$ ]& @4 N' k$ L# D
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     
101. }
     
102. int main()
     
103. {
     . o) }: F8 }7 w7 B2 l1 c
104.         void PrintU16(uint16_t num);
     * M# G- ^" @& o; u' j
105.         void PrintHexU8(uint8_t data);
     % M9 a4 W, j) U& B& Z+ X' m$ k% t
106. 
     2 z$ d! D$ L3 P
107.         Adc_Init();
     
108.         adc_nvic_init();
     
109.         usart_init();
     3 d$ v1 A: t, `7 D) N7 X8 P
110.         while(1)
     
111.         {
     
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     % ?- O4 ^0 A' t6 P2 K
113. 
     
114.                 PrintU16(num);
     
115.                 delay(1000);
     , J7 j" x5 a0 f7 w$ ~' d
116.         }
     & V# `, ~1 z- Y' x4 u
117. }
     : s; a3 y  t% v% U2 ~8 @6 C. s  S  y. Q
118. 
     / Q% c5 J- p* N6 Z+ F$ v9 i5 U
119. void PrintU16(uint16_t num)
       x$ s9 z! D4 y: m
120. {
     
121.         void PrintHexU8(uint8_t data);
     
122.         uint8_t w5,w4,w3,w2,w1;
     
123.         w5 = num % 100000/10000;
     0 C5 [! u* O) X$ p3 w
124.         w4 = num % 10000/1000;
       Z* k  C# @' y1 O1 p
125.         w3 = num % 1000/100;
     * S  l* ~  c0 M8 g$ f4 w
126.         w2 = num % 100/10;
     
127.         w1 = num % 10;
     
128.         PrintHexU8('0' + w5);
     % g9 t- S! M& {# [9 L% X' b
129.         PrintHexU8('0' + w4);
     0 C0 A% |+ Y! J5 [9 f: k3 F
130.         PrintHexU8('0' + w3);
     $ z8 {5 X/ t2 ?4 ]0 X- ]* P
131.         PrintHexU8('0' + w2);
     
132.         PrintHexU8('0' + w1);
     ) C8 z- i; M: S$ G! ^& ]
133. }
     
134. 
     
135. void PrintHexU8(uint8_t data)
     ) T& ^$ a3 n! M9 |: ^
136. {
     
137.         car = data;
     $ j3 A, P: D& m/ Y
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     4 r& f8 s7 o# E, s0 m! w
140. }
     
141. 
     % ^" X0 [' K4 ]- ~: t
142. void ADC1_2_IRQHandler()
     
143. {
     7 j5 N1 O$ F/ o2 K* ]* t
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     
145.         {if(count_1%2 == 0){
     
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     
148.         }else
     ! |0 @0 P1 y3 M2 E5 u9 q
149.                         {
     
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     
151.                                 count_1++;
     # r1 O5 s% A  x0 ]+ j
152.                         }
     # d) z; A7 K+ R
153.         }
     $ X0 R+ p2 @# A
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     
155. }
     ! W  m; e8 ?$ U  K
156. 
     
157. void USART1_IRQHandler(void)
     + ]$ Z: Y+ M( z' R$ o- E
158. {
     2 t7 c" x6 x, I( D: k4 n3 B: D# [
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     6 A, x; \' x& a; c( k3 |8 O" c7 C
160.         {
     
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     4 @$ |0 [7 w& O" k0 r0 G% w: V
162.                 USART1->DR = car;
     . x& W8 l+ o- e+ Y. m- _2 e1 w) o
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
     
165.         }
     
166.        
     
167.         if(USART1->SR & USART_SR_RXNE)
     : ~1 |' Y" ~# n" M  y
168.         {
     
169.                 volatile int8_t com_data;
     9 p3 @5 Q0 j% }- d+ M
170.                 com_data = USART1->DR;
     
171.         }
     
172. }

复制代码

$ j! J" E7 M  D6 L8 M! [————————————————
版权声明：家安
6 \2 x' `; m# I+ _# W( `
0 V- p3 S) P, P* A: C' X% {
; ?% o* B, Z& s. X/ G* E