通过中断方式读取电压，不过最后楼主读取参考电压失败，还没有找到错误，所以读取的电压只能十六进制显示，
1 Z2 z) I0 b# I9 C' d- l
本文的介绍按照一般流程来走：
# F! [7 N  a  S1，串口的初始化
2，ADC初始化
3，中断初始化
4，编写中断函数
8 _- P9 _5 @/ k- V  X5 }5，编写主函数

1 w: C( c& M4 O. A* R8 N接下来详细介绍：

1，串口的初始化：
' \( y! A2 R$ }, ]1 M: {0 _

1. void usart_init()
   + Q! a: ^6 }9 k- S7 C* c, A$ q
2. {
   
3.          GPIO_InitTypeDef Uart_A;  
   
4.       
   
5.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
   5 A! J1 s: T2 S, P( M( b8 V
6.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
   
7.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
   3 `8 G/ F  X6 E; x( B
8.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
   ( r9 A5 a+ ?: v! l' C! J5 Y
9.     GPIO_Init(GPIOA,&Uart_A);  
   : z6 J2 W% z) N, m
10.       
    9 u$ U2 o  Z- [+ @  \* n
11.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    
12.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
13.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    2 W0 b$ Z# Y% n% v& i: O& H
14.     GPIO_Init(GPIOA,&Uart_A);   
    
15.        
    
16.         USART_InitTypeDef Uart;  
    ( `5 i1 ?& B& _& D& W) m7 @
17.       
    ( L  P. x5 I2 r* f( p
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    
19.     Uart.USART_BaudRate = 115200;  
    
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    . s) G, u. y* U' a, A" Y$ B
21.     Uart.USART_Mode = USART_Mode_Tx;  
    
22.     Uart.USART_Parity = USART_Parity_No;  
    
23.     Uart.USART_StopBits = USART_StopBits_1;  
    9 i0 m" O- F: L5 {  B
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    0 c' b) g4 R) K: n! [; P
25.     USART_Init(USART1,&Uart);  
    
26.       
    
27.     USART_Cmd(USART1,ENABLE);  
    
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
    ( k$ o. A0 w4 N) j. r
29. }

复制代码

; e) _2 T! u6 l1 [% j# B' ^关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。
: F% ^9 o6 f" M
# s$ x& L. l5 c4 y
1 c, |5 d2 E8 F1 l  j- c; V5 F2，ADC初始化
2 Y9 Y% F9 z4 K) T& {

1. typedef struct
   7 Z& P6 x; p3 K9 p, w
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   , i% P  r* n6 X5 O+ n& T5 ^% z
4.                                                dual mode.
   
5.                                                This parameter can be a value of @ref ADC_mode */
   . r* ?7 M4 `$ [1 ]% C% x% q2 p/ x
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   
8.                                                Scan (multichannels) or Single (one channel) mode.
   
9.                                                This parameter can be set to ENABLE or DISABLE */
   ) L$ I  T, f1 g! y7 Y
10. //配置ADC是单次转换还是连续转换
    # ~: ~. ]  P6 c* B+ q& [
11.   FunctionalState ADC_ContinuousConvMode; /*!< Specifies whether the conversion is performed in
    # K# u& y% Z3 Y2 ~( c3 k
12.                                                Continuous or Single mode.
    ! Y7 i% z8 s5 f2 A
13.                                                This parameter can be set to ENABLE or DISABLE. */
    # j, \3 N5 I# n7 Z; x+ A
14. //外部触发选择
    / m0 \5 l- D+ z# s7 z# [+ J
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    : \1 c+ s& l( \8 ]. L7 }% i3 |- ]" B
16.                                                to digital conversion of regular channels. This parameter
    
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    * q6 q" P* V+ ?" k, Z6 [
18. //转换结果数据对其方式
    0 ~9 F. f: o* g
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 */
    ; x; X+ u0 l; o9 S
21. //ADC转换的通道数目
    
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    . g. n' o: r" x) z2 t& s: j
23.                                                using the sequencer for regular channel group.
    
24.                                                This parameter must range from 1 to 16. */
    " u4 u6 n  \" V% p8 N
25. }ADC_InitTypeDef;

复制代码

# n: u) |% ~" d+ }% E
% v! E% R% V) ]+ A下面粘贴代码：
" V8 c& u7 u' k/ N) ~+ r. O+ ]8 S2 s

1. void Adc_Init()
   
2. {
   % S! z; n& \% f3 ]  ?) N
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
   
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   
5.        
   $ a1 j" w1 O8 \  C
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
   1 U2 t+ v- T/ X/ ], q
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   
8.        
   & p# D3 J- H4 R/ m  {; T
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    , h" V- x  q- x& ^9 r
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    1 E  A1 }: O( {+ B, Q; G, ~6 S- g
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    , a2 D# Q+ W: a3 h/ B: Q
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
    
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    ! y- S3 x, L7 f' F/ K
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.        
    
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
      v7 T! u. t" J) z; w6 ?
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    & F' s- H! x6 S
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    ( F' x3 v( `5 t$ V6 Z
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    ; k0 B6 P" [& g' _" C/ C: ~  F
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    1 {; ~* e  h$ s) |' p- {  o
29.        
    ) L- C5 U# L9 v
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    ) Y) a/ O0 p0 @% E! h( ]- x
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    9 T7 N  g3 P( ?  c, A' P
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    
33. }

复制代码

3.中断初始化
7 b! K" a' p" G1 z

1. void adc_nvic_init()
   
2. {
   
3.        
   
4.         NVIC_InitTypeDef nvic;定义中断结构体
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   " v0 A8 A" R1 r2 s' ~
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   ) @; n  ^% z$ O1 W
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   
10.         NVIC_Init(&nvic);初始化
    8 |; I' U) X5 G! F1 a$ j& h
11.        
    2 B+ E" D) D) R( t
12.         NVIC_InitTypeDef usart1;定义中断结构体
    
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    4 Z& X- Z: q9 h7 O# E
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    : y) [4 l. z9 s0 F8 G
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    * R; G0 l: ^5 x) \
18.         NVIC_Init(&usart1);中断初始化
    
19. }

复制代码

7 ~3 K7 I+ l+ p$ F0 t7 l4，编写中断函数
先粘贴代码：

1. void ADC1_2_IRQHandler()
   
2. {
   / n6 f# e2 G6 s, B6 Z
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   $ z3 X4 |5 \4 @) F+ I
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   
6.                 count_1++;
   
7.         }else
   
8.                         {
   % [$ d. z. @" ^, X5 H' k
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   . m: z6 T/ D, ~" T+ Y- F# P9 T" h
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    5 j* j5 R& h' r" ]
11.                                 count_1++;
    
12.                         }
    8 P7 z( I0 X9 ^1 _% A! S  Q
13.         }
    " k5 Y' S; b( t  Y0 x
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    
15. }
    
16. 
    & u& c& p& [: i8 }0 @( {8 p
17. void USART1_IRQHandler(void)
    
18. {
    8 @; B& K, Y5 a& U8 h3 B
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    
20.         {
    
21.                 USART1->CR1 &= ~USART_CR1_TXEIE;在这里笔者也碰到了问题，详见下文
    . M% P+ z; A8 J' V  _( t/ @
22.                 USART1->DR = car;
    " A: _. s9 K5 w0 ]7 A$ ^5 u, j
23.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    0 C! h7 \5 D, c. m) c. f
24.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
    % S" `9 t2 `. |( q) l# z
25.         }
    
26.        
    $ X: r! e- N  A9 t
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    
28.         {
    
29.                 volatile int8_t com_data;
    
30.                 com_data = USART1->DR;
    ! g- a( Q5 X2 C+ s% X8 S
31.         }
    : l7 {, |  x2 [/ r
32. }

复制代码

在ADC中断服务函数中，代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的，因为第一次接受的是外部电源电压，第二次接受的是内部参考电压，所以可以利用奇偶数，即偶数用ADC_ConvertedValue来存放外部电源电压值，奇数时用ADC_ConvertedValue_1来存放参考电压值。但是，笔者发现，这样会失败，经过串口调试发现两次接受到的值都一样，笔者初步认为，可能是ADC的转换速率太快了，具体什么歌情况还不清楚，等下一个基础设计ADC转换（DMA方式）的时候在细究。
# C2 i; {8 ]$ x2 r; _3 f
8 m. Z7 w" p( J" |( t% C) y关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。
. t: L. I6 l3 v$ ?
8 Y+ V' F% R5 M/ `6 u8 M1 K---------------------------------------------------------------------------------------------------------------------------------

5，编写主函数

1. int main()
   $ Y+ \5 T9 q4 ^1 m  Y! {
2. {
   0 q3 f+ S. b: ^# G* C5 P! y
3.         void PrintU16(uint16_t num);
   
4.         void PrintHexU8(uint8_t data);
   
5. 
   + D8 Q6 P" |* S! M1 R% Z
6.         Adc_Init();
   9 K2 T( r+ t; `: \9 H
7.         adc_nvic_init();
   + z2 g" p, d+ y- A
8.         usart_init();
   1 k0 u- D% ]2 n* e" }
9.         while(1)
   
10.         {
    / K7 `# i+ A5 w: c* _
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    ; @" ~6 q8 t0 O4 Q- X
12.                 PrintU16(num);
    
13.                 delay(1000);
    ( f9 S; y+ G, ?% Z% Z
14.         }
    
15. }

复制代码

5 D" y: v0 q/ [* S' V
3 R5 R2 B! d  ]% y0 L2 ~! P- b笔者并没有计算出准确的电压值，只是采集到两个电压值，笔者猜测，可能是因为ADC的转换速率太快，导致笔者的  通过奇偶数来区分内部电压和外部电压不管用了，笔者还在思考解决方式，如果读者有好的方法，请指教。

1 K/ {! y: V+ k; c# J, {
0 [; c' g, v: ~本文到此结束，下面是完整代码：

" u( d7 C7 ?; s: X$ c

1. #include<stm32f10x.h>
   5 V" D# v: @- G5 Q6 O
2. #define uint unsigned int
   + x8 V1 B; r7 O; C+ D
3. #define uchar unsigned char
   , @9 p  D4 ~+ k9 O- Z
4.        
   ! ^4 p/ m1 X: q  Z1 e# Z% O+ l
5. char car;
   
6. static char count_1=0;//当做奇偶数
   ; e' X  m$ C; b: p4 h
7. uint16_t ADC_ConvertedValue;//存放电源电压
   5 @- t* ^8 n% D  [& g$ n# c* l! M
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   , V! e1 f+ O* ~
9.         static uint16_t num=0;
   
10. void delay(uint n)
    
11. {
    
12.         int i,j;
    0 y; {$ ]* v; d% P. W
13.         for(i=0;i<n;i++)
    $ l4 g5 k; m8 I2 o
14.         for(j=0;j<8500;j++);
    
15. }
    / \2 `- Y& t' |% [1 O
16. 
    
17. void Adc_Init()
    
18. {
    
19.         ADC_InitTypeDef adc;
    ) E6 q: S1 x% ^8 Q0 E% Y
20.         GPIO_InitTypeDef io_b;
    2 w7 y+ \' p" H( [2 k
21.        
    - F) Z) a+ t- V5 h5 l9 }
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    $ g, J" @1 U% a1 v8 h/ d
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    6 E- v; k1 ?. Z; ?& p
24.        
    
25.         io_b.GPIO_Pin = GPIO_Pin_1;
    
26.         io_b.GPIO_Mode = GPIO_Mode_AIN;
    
27.         io_b.GPIO_Speed = GPIO_Speed_50MHz;
    2 a: q* U" r/ Q7 f5 n
28.         GPIO_Init(GPIOB,&io_b);
    . x; ]6 H: |, `$ m! m7 Y
29.        
    2 k" k2 I) L! s  A, F
30.         ADC_DeInit(ADC1);
    
31.         ADC_TempSensorVrefintCmd(ENABLE);
    
32.         adc.ADC_Mode = ADC_Mode_Independent;
    2 \( E& U8 c$ `# G( w! E( j4 F0 w
33.         adc.ADC_ScanConvMode = ENABLE;
    " o/ Y( H6 a+ K& }
34.         adc.ADC_ContinuousConvMode = ENABLE;
    
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    
37.         adc.ADC_NbrOfChannel = 2;
    . M3 d1 p7 D, V
38.         ADC_Init(ADC1,&adc);
    . }. W* ~% A* d) j& \1 \9 @
39.        
    ; `. C3 Y* o0 P
40.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    
41.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    " @: n! o) v: ?8 \$ S& m9 `9 X+ O
42.        
    ; ]# Z! \8 m8 n. p. B6 |4 n5 Q
43.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);
    / A- I: W- f- h4 D+ j- F& v( F
44.         ADC_Cmd(ADC1,ENABLE);
    
45.         ADC_ResetCalibration(ADC1);
    
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    
47.        
    
48.         ADC_StartCalibration(ADC1);
    ) U" m9 P) u2 R, e
49.         while(ADC_GetCalibrationStatus(ADC1));
    
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    
51. }
      ~- \. W% Q3 s, G! q9 Z# V& ?
52. 
    6 B( e- @/ s+ L5 h$ ^$ P7 ^+ ]
53. void adc_nvic_init()
    ) Q7 E4 S: ^8 X5 b% _3 h: H+ D: @
54. {
    8 c/ R, w4 [# J# C2 c6 @- ~, g
55.        
    
56.         NVIC_InitTypeDef nvic;
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    3 b5 s" e8 v: \2 W8 D6 {0 R
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    # O% U1 g' U( e- [; d" f3 \3 k
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    
62.         NVIC_Init(&nvic);
    8 P# [$ d" W& }  D9 p
63.        
    " Z% w6 p4 j8 K7 t3 f
64.         NVIC_InitTypeDef usart1;
    
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    7 ?8 q+ P6 N  Z- R
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    
70.         NVIC_Init(&usart1);
    
71. }
    # j4 r6 I8 e' T, r& E4 c( C9 T& r, P! k
72. 
    
73. void usart_init()
    0 h5 b4 d  Y( K5 m' c) i
74. {
    1 H5 k2 D, u: f, @
75.          GPIO_InitTypeDef Uart_A;  
    
76.       
    
77.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
    : i! m0 o% H# O, A7 j! S- {
78.     Uart_A.GPIO_Pin = GPIO_Pin_9;  
    # r" V( ?9 E+ H7 V0 F& {9 B5 }1 w
79.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
80.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
    ) b8 ~1 H# y* g( }, t6 e& F0 u
81.     GPIO_Init(GPIOA,&Uart_A);  
    
82.       
    $ M. K5 l6 J2 c+ _, }, Q
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    ' s% v5 t! q6 u/ @
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    & V3 I  i3 C8 g6 N( m( D2 ~1 ?
86.     GPIO_Init(GPIOA,&Uart_A);   
    / v: Q3 |7 A. |( z4 o0 A. `
87.        
    
88.         USART_InitTypeDef Uart;  
    9 F" w0 S; P8 v3 n
89.       
    
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    
91.     Uart.USART_BaudRate = 115200;  
    5 h+ ~* Q* v4 X8 Q
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
93.     Uart.USART_Mode = USART_Mode_Tx;  
    - t( X5 u$ H' t# `) ]
94.     Uart.USART_Parity = USART_Parity_No;  
    ; i% R4 E* k' [9 G, M' j
95.     Uart.USART_StopBits = USART_StopBits_1;  
    
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    " l/ |1 t* F& B; m. X2 b% x
97.     USART_Init(USART1,&Uart);  
    - o7 x/ x5 \0 L
98.       
    
99.     USART_Cmd(USART1,ENABLE);  
    
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     
101. }
     ) T4 d! Q& }. z, ]& y( n
102. int main()
     # J" w3 J( O3 O5 L+ i' a2 O
103. {
     
104.         void PrintU16(uint16_t num);
     & p6 A/ c; d/ S( V: K
105.         void PrintHexU8(uint8_t data);
     
106. 
     ( @! u1 i7 e# b! b5 i1 j
107.         Adc_Init();
     
108.         adc_nvic_init();
     
109.         usart_init();
     
110.         while(1)
     8 n. r, `3 H+ t2 }1 N
111.         {
     
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     
113. 
     ; N# q9 [: }; V' C" v0 e
114.                 PrintU16(num);
     / j# ]* e# `  @: Q+ q
115.                 delay(1000);
     6 D) p' {  M- s' F5 H% q
116.         }
     $ a7 w0 k3 b0 o) m, U/ j5 K  m
117. }
     $ I1 ]3 d# h" i
118. 
     ) w: h1 {2 s& k. a- C' L" C
119. void PrintU16(uint16_t num)
     
120. {
     ) N" m7 @7 k! C0 M  @. p; F
121.         void PrintHexU8(uint8_t data);
     
122.         uint8_t w5,w4,w3,w2,w1;
     : B( S& d$ x' u- c5 {+ T" Q
123.         w5 = num % 100000/10000;
     ; J# f5 C8 H2 I9 G; L3 X' ~; }
124.         w4 = num % 10000/1000;
     
125.         w3 = num % 1000/100;
     
126.         w2 = num % 100/10;
     
127.         w1 = num % 10;
     
128.         PrintHexU8('0' + w5);
     : C( v, p6 D: ^
129.         PrintHexU8('0' + w4);
     
130.         PrintHexU8('0' + w3);
     4 |3 A- f( t1 D/ l) @# V
131.         PrintHexU8('0' + w2);
     / X" @. i, t" v1 P1 _, b" L
132.         PrintHexU8('0' + w1);
     
133. }
     , i  U9 ?% `# D" C$ Z* a
134. 
     
135. void PrintHexU8(uint8_t data)
     
136. {
     
137.         car = data;
     - }& _. T+ K* I2 r& F0 T
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     
140. }
     
141. 
     
142. void ADC1_2_IRQHandler()
     / I# H1 c. j6 ^5 G. ^
143. {
     5 `1 P- N! @* [% Z
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     
145.         {if(count_1%2 == 0){
     
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     / v' o' F3 Z: w; n% ~/ q
148.         }else
     
149.                         {
     
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     
151.                                 count_1++;
     
152.                         }
     
153.         }
     " O" Y' {/ K) [+ b# }4 I
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     
155. }
     
156. 
     
157. void USART1_IRQHandler(void)
     
158. {
     5 J3 v! r$ z# O- H4 f
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     : ~. \7 }! J' u* P5 a) J* i6 I
160.         {
     
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     
162.                 USART1->DR = car;
       V4 R/ u0 k- M) [# c
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     0 X# I; q; s0 l( P  J! E* V- j7 A
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
     ' B  t% U/ [4 P" @% M
165.         }
     0 V  `( S3 @2 T: c, x- F3 N
166.        
     ) r5 Q: G2 b6 G* L9 ^  L; o
167.         if(USART1->SR & USART_SR_RXNE)
     ; A# ]% {# Q. n2 Z
168.         {
     
169.                 volatile int8_t com_data;
     
170.                 com_data = USART1->DR;
     
171.         }
     3 B" R! @8 o1 M% p, s( p
172. }

复制代码

————————————————
版权声明：家安
! E) p7 Y; N* l3 W) f& b+ R
% {' e4 U: n! Y+ X* K/ q