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

本文的介绍按照一般流程来走：
1，串口的初始化
/ @: w- D, S3 D$ b/ W2 z2，ADC初始化
7 @4 k7 @, j# U" c# C: d3，中断初始化
4，编写中断函数
, ~/ x2 M9 O- D- u. H5，编写主函数

3 C4 |. _& f$ f1 p( O( w1 N& [% c接下来详细介绍：
3 O6 ~  j9 J2 e' e1 z8 o+ |" p# R
1，串口的初始化：
( Z. ?8 M5 R& M+ T! {' Y% ^7 q/ v

1. void usart_init()
   
2. {
   $ e$ C) }* j$ J8 ^* U
3.          GPIO_InitTypeDef Uart_A;  
   
4.       
   
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;  
   
9.     GPIO_Init(GPIOA,&Uart_A);  
   
10.       
    8 }3 H% V; c" P5 L: i# Q
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;
    6 m: e  E8 S/ t% f* ~9 `) d. m
14.     GPIO_Init(GPIOA,&Uart_A);   
    ! P5 j' f7 o$ x" y, d
15.        
    6 _7 b% S+ }; Z5 x/ ^
16.         USART_InitTypeDef Uart;  
    
17.       
    
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    0 s. Y. B% n. B! P3 K' h3 {( E
19.     Uart.USART_BaudRate = 115200;  
    ) n/ I& t" S/ J- N
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    2 o4 s1 {% f8 t. a( x
21.     Uart.USART_Mode = USART_Mode_Tx;  
    & Y" ~4 P" M6 F1 d0 I$ @
22.     Uart.USART_Parity = USART_Parity_No;  
    ! t0 U! R; G+ }( N1 Q
23.     Uart.USART_StopBits = USART_StopBits_1;  
    
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    
25.     USART_Init(USART1,&Uart);  
    
26.       
    
27.     USART_Cmd(USART1,ENABLE);  
    + Q3 n  z9 i$ L# y) y! q3 E: H5 g
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
    2 B% j3 m- ]* n. x# P
29. }

复制代码

3 ~  V) i, ^4 u7 A. L6 c
关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。
; L  Z8 m% A+ K6 e( I

; o8 W. M6 v# o* x2，ADC初始化

1. typedef struct
   4 p. U* F7 e- o6 R/ K3 o* w
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   ! A( S) J% G6 }9 _5 }
4.                                                dual mode.
   
5.                                                This parameter can be a value of @ref ADC_mode */
   5 z8 S" u% q$ A. I0 B( a2 ?5 K
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   1 r& u( E4 i+ X3 V/ K2 n
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   + w' N- g, o. [
8.                                                Scan (multichannels) or Single (one channel) mode.
   
9.                                                This parameter can be set to ENABLE or DISABLE */
   
10. //配置ADC是单次转换还是连续转换
    % e) p/ [, A! ~0 O0 @. y' n( w
11.   FunctionalState ADC_ContinuousConvMode; /*!< Specifies whether the conversion is performed in
    
12.                                                Continuous or Single mode.
    % v& n/ ?' p0 ?/ K/ _
13.                                                This parameter can be set to ENABLE or DISABLE. */
    
14. //外部触发选择
    
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    : M6 l) U' g/ q% g# l: q
16.                                                to digital conversion of regular channels. This parameter
    2 W4 l  c: m" ^
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    1 K7 H* i. c  B1 L8 Y
18. //转换结果数据对其方式
    5 h8 t0 a: \3 [! r$ Z9 J" K
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 */
    
21. //ADC转换的通道数目
    / e+ p0 G, Z/ b0 B4 Z8 n+ Y, w
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    * U4 v3 H# T% m7 Q! [" I; v
23.                                                using the sequencer for regular channel group.
    % I( q. M2 I7 V* H! }; \
24.                                                This parameter must range from 1 to 16. */
    3 S, i0 ]0 u. {9 m! M
25. }ADC_InitTypeDef;

复制代码

下面粘贴代码：

1. void Adc_Init()
   8 W( B! H( E- k3 c& u
2. {
   
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
   - N) `! s0 w: B/ p; P5 D$ U# _- U& `
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   
5.        
   / P/ ~. ]! L$ f. H" d3 X8 m$ B7 [7 P
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
     `) ]9 L  r6 C* y' @
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   + ]) U/ k3 u  S7 D9 r+ e5 V7 \
8.        
   + q; l. p$ b' Y6 R8 G
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    9 E: h" o: d6 x8 f
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    % W7 j0 h: ^  u' g0 r* ?
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    1 k' x+ r% N( X4 Z1 r- M' J
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
    
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    ; I% y  ^* d! i/ X+ F; g: z
16.         adc.ADC_ContinuousConvMode = ENABLE;使能连续扫描
    & |  k# Z' D5 l! w' U# y6 h
17.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发
    4 a9 M. L3 T/ a) T1 h/ M3 v
18.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据右对齐
    2 N! f# R+ C4 V: Z7 r
19.         adc.ADC_NbrOfChannel = 2;来制定用几个ADC通达（勿忘）
    2 [: @* @3 p- v$ H6 }
20.         ADC_Init(ADC1,&adc);初始化ADC寄存器
    2 x' j' Q! ?! z! Y# @
21.        
    6 f$ P8 F( P" }2 F' ]
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    . ]+ W7 c& X9 e- P8 |5 ^6 `
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    6 G$ O, L0 p$ ~3 {
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    / ?+ ?+ X# A3 X! B
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    * r  d4 H. F( W3 c* @+ `( Y3 O
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    + K, b# I6 w' a, O
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    3 Z1 p- x, A+ T* j+ o  p2 }
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    
29.        
    . F( Q; v9 [! F' s2 j" [
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    5 Y+ N4 T2 L( i% l5 M3 d2 s
33. }

复制代码

3.中断初始化
5 i( h$ [  L- Y

1. void adc_nvic_init()
   
2. {
   
3.        
   
4.         NVIC_InitTypeDef nvic;定义中断结构体
   # U4 ?; j) `8 Z/ n$ ^8 v  b
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   ) a, ^/ n* f: q
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   7 M& P1 u2 y1 B& ?" f* A& T
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   1 o+ O+ |: j4 u9 w; ?
10.         NVIC_Init(&nvic);初始化
    " k$ f9 u7 S; Y
11.        
    
12.         NVIC_InitTypeDef usart1;定义中断结构体
    $ H4 m8 c; E; m/ k
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    
18.         NVIC_Init(&usart1);中断初始化
    
19. }

复制代码

9 G7 d% q5 Y! \8 `" i
- y) T" x& F. p/ v  ^3 q4，编写中断函数
先粘贴代码：
& K7 L' b, N4 i2 h) v8 x% Q  j

1. void ADC1_2_IRQHandler()
   
2. {
   
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   
6.                 count_1++;
   6 c8 M6 z& u, G
7.         }else
   
8.                         {
   , c0 A/ V1 d, @8 h2 {
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   ( Q' ~9 e8 t) X5 {: K7 e/ k1 E
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    
11.                                 count_1++;
    ( d( W+ y( I# [/ B8 g% I
12.                         }
    
13.         }
    
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    7 O- W3 p8 E: x3 K. S/ x$ l
15. }
    
16. 
    
17. void USART1_IRQHandler(void)
    - T2 v" W: e0 O5 {' H; M
18. {
    , W1 q- L  P, e3 h" N6 V8 Q+ ?0 L+ \
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    
20.         {
    9 ?; e0 X( w) W8 T* w( C. g
21.                 USART1->CR1 &= ~USART_CR1_TXEIE;在这里笔者也碰到了问题，详见下文
    
22.                 USART1->DR = car;
    
23.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    7 a7 j5 B7 d$ a! q- H$ {0 L
24.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
    : h  a3 B' M1 I9 K8 V! e" X- e+ Q
25.         }
    % E* o5 z, @' x& x
26.        
    : n) e7 M  J7 N. D
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    
28.         {
    2 t1 n# \# e$ d1 Q* u
29.                 volatile int8_t com_data;
    * c- H$ x& B0 a' g9 X
30.                 com_data = USART1->DR;
    
31.         }
    1 P* }0 J9 v) ?7 \: o- Z
32. }

复制代码

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

1 B/ q7 B, E) r* v( i  M" m" i关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。
( k+ [* @& a$ W( y
: S* G* v6 n0 f' x) {1 m---------------------------------------------------------------------------------------------------------------------------------
( |# D; B  t1 O9 z
5，编写主函数

1. int main()
   
2. {
   3 T$ V6 j# m! G+ E
3.         void PrintU16(uint16_t num);
   ; F/ L5 }3 C& n; h$ f
4.         void PrintHexU8(uint8_t data);
   
5. 
   & v9 ~( U1 S! I- u5 Q6 R! ?! B& K
6.         Adc_Init();
   * S; I; A  A2 _4 F- E
7.         adc_nvic_init();
   ; s6 u7 o6 y& z% [( k& b
8.         usart_init();
   
9.         while(1)
   
10.         {
    / a9 e$ I6 V) U8 x
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    
12.                 PrintU16(num);
    3 ?/ ]: k) _8 }! |* z3 L6 Z
13.                 delay(1000);
    
14.         }
    
15. }

复制代码

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

% O$ c4 u( n: l5 J8 D# n
9 V" ?1 _5 l; |本文到此结束，下面是完整代码：

1. #include<stm32f10x.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   1 f3 R! m1 R8 N$ h% y: p
4.        
   " _$ H# x, k! V7 x/ s0 J7 X
5. char car;
   
6. static char count_1=0;//当做奇偶数
   $ O, [8 y( V& Z4 B5 k  d
7. uint16_t ADC_ConvertedValue;//存放电源电压
   
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   
9.         static uint16_t num=0;
   + z* l$ n4 S  Q3 A# S, p5 x" N" C
10. void delay(uint n)
    
11. {
    
12.         int i,j;
    3 ^$ B/ n4 Q$ d2 r9 B$ r
13.         for(i=0;i<n;i++)
    
14.         for(j=0;j<8500;j++);
    " M6 A6 [" t$ y& F
15. }
    
16. 
    1 a' s5 w7 A, c$ X
17. void Adc_Init()
    
18. {
    ! h5 h7 \3 v( a
19.         ADC_InitTypeDef adc;
    2 b$ G" k$ J; K, y2 O8 k; C
20.         GPIO_InitTypeDef io_b;
    # u3 J) r' y2 Y' U( |7 W- S
21.        
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    * G8 W, k* ]/ \' a% v" h
24.        
    . k. f7 W( k. J: E
25.         io_b.GPIO_Pin = GPIO_Pin_1;
    ' c" p* r, |- Y5 Y7 S' a7 d
26.         io_b.GPIO_Mode = GPIO_Mode_AIN;
    
27.         io_b.GPIO_Speed = GPIO_Speed_50MHz;
    - C7 i4 Q& q9 b7 w! r' M% p) o! o
28.         GPIO_Init(GPIOB,&io_b);
    
29.        
    
30.         ADC_DeInit(ADC1);
    
31.         ADC_TempSensorVrefintCmd(ENABLE);
    0 v/ ^) O+ e4 _
32.         adc.ADC_Mode = ADC_Mode_Independent;
    
33.         adc.ADC_ScanConvMode = ENABLE;
    
34.         adc.ADC_ContinuousConvMode = ENABLE;
    : I' b6 m- N( _0 r9 _9 M# x
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    . A" d! L+ x3 B" ?
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    : d6 Y7 |: \1 B' `9 i& u
37.         adc.ADC_NbrOfChannel = 2;
    
38.         ADC_Init(ADC1,&adc);
    ( W0 k- `! m, A, c* B( t- U
39.        
    ; a2 W3 _7 j) P5 b$ ]* l8 k8 L
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);
    6 ]  ?) K% V$ F' ~6 E& T( E( r
45.         ADC_ResetCalibration(ADC1);
    / j0 \, {7 }+ u) ]
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    
47.        
    
48.         ADC_StartCalibration(ADC1);
    
49.         while(ADC_GetCalibrationStatus(ADC1));
    8 R" n7 O- I5 S
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    
51. }
    $ m3 J  a9 _- F( n5 }+ K4 c
52. 
    ! H1 e( w( E& T# [& T) C
53. void adc_nvic_init()
    
54. {
    
55.        
    
56.         NVIC_InitTypeDef nvic;
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    9 b3 w# a# M; L& n8 b8 o. M3 b
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    % H# @2 j  S- I1 B* {6 O6 V
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    $ \6 [$ e9 M$ R/ @
62.         NVIC_Init(&nvic);
    
63.        
    
64.         NVIC_InitTypeDef usart1;
    
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    ! @3 l# h- d9 M
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    5 @3 X. q3 w: u- u) `3 Y9 Q
70.         NVIC_Init(&usart1);
    
71. }
    
72. 
    % G. T& P; v  k" I
73. void usart_init()
    
74. {
    
75.          GPIO_InitTypeDef Uart_A;  
    9 |$ ~# b2 n: p+ ]+ H9 k+ r9 f9 e$ Y
76.       
    
77.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA ,ENABLE);  
    * {/ I* t9 v( }
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;  
    
81.     GPIO_Init(GPIOA,&Uart_A);  
    : l6 x: ^7 r3 v9 r+ ^
82.       
    
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    . e1 I% K7 S' ]5 ]# z# t
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
86.     GPIO_Init(GPIOA,&Uart_A);   
    
87.        
    
88.         USART_InitTypeDef Uart;  
    
89.       
    
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    6 a4 ?+ L, c/ Q- f, l. T( g
91.     Uart.USART_BaudRate = 115200;  
    ) i1 ]8 T- f9 V; h$ Z
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
93.     Uart.USART_Mode = USART_Mode_Tx;  
    3 L4 Z$ X! `/ A5 Q' a
94.     Uart.USART_Parity = USART_Parity_No;  
    ( X, y, K. q/ x4 \& J4 |0 i; }* J
95.     Uart.USART_StopBits = USART_StopBits_1;  
    5 Y; p, c' `: |# K" n
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    * H2 M. {$ {0 @
97.     USART_Init(USART1,&Uart);  
    7 n# P/ n$ W  ~* Z9 X: ^
98.       
    $ ^* m6 S* i  q& g6 F. w- i" D
99.     USART_Cmd(USART1,ENABLE);  
    6 y" c. ^6 r* ]) y; d" \
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     
101. }
     - C8 @  U& k: O  I" _0 s
102. int main()
     4 G9 T$ G( K3 D, Y# U! h5 g1 v& p
103. {
     ) a% ?2 |# X: r7 |1 V
104.         void PrintU16(uint16_t num);
     
105.         void PrintHexU8(uint8_t data);
     $ v8 j* X; b$ ~  a
106. 
     . w1 Y4 I; f7 J# `' t4 K2 D
107.         Adc_Init();
     
108.         adc_nvic_init();
     # J0 [6 J* I, M
109.         usart_init();
     2 i" X- m; L$ E. d9 f, e) E! q
110.         while(1)
     
111.         {
     $ R+ i* B4 Y* B# a  U; x2 [
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     
113. 
     ! [. ?" ]) n$ I- o1 n0 u
114.                 PrintU16(num);
     6 @+ f& ~9 K$ y0 }* S
115.                 delay(1000);
     
116.         }
     
117. }
     ) X  k2 d0 A. K: C4 H+ k* Q
118. 
     : E+ O& a1 c  J" j1 O/ c9 V  Q
119. void PrintU16(uint16_t num)
     
120. {
     
121.         void PrintHexU8(uint8_t data);
     , a/ r" G) q. _, N0 @, M0 d
122.         uint8_t w5,w4,w3,w2,w1;
     
123.         w5 = num % 100000/10000;
     ! G' X! T( d/ {+ ~
124.         w4 = num % 10000/1000;
     * J/ z! u9 @: u7 \4 k
125.         w3 = num % 1000/100;
     
126.         w2 = num % 100/10;
     . @- w. i. K2 W! R1 }2 J, _( s0 V" E
127.         w1 = num % 10;
     " c3 X7 g* m7 Y2 u" V! S2 d
128.         PrintHexU8('0' + w5);
     , ?7 P. [5 {$ p: @! P  E- A
129.         PrintHexU8('0' + w4);
     
130.         PrintHexU8('0' + w3);
     
131.         PrintHexU8('0' + w2);
     . _3 d. v" ~) J! X* s( v
132.         PrintHexU8('0' + w1);
     
133. }
     6 B! P( m3 j$ e' F  T1 ^
134. 
       N, K3 ]- _: b6 L# z
135. void PrintHexU8(uint8_t data)
     
136. {
     ' Y2 m  I# ^+ j9 B
137.         car = data;
     & X! I4 A, j' A7 E7 G: j; o
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     : O  Q% U# @- G7 V5 x! O8 |# b
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     
140. }
     
141. 
     
142. void ADC1_2_IRQHandler()
     
143. {
     2 U3 Y, Y  ]' k3 [
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     
145.         {if(count_1%2 == 0){
     & S% Z( k; L' P6 s1 i  i; a
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     
148.         }else
     # s1 B7 n$ ?; h2 {
149.                         {
     
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     ; j& H/ y4 R4 s: A
151.                                 count_1++;
     , c* F5 x; F) d8 Y$ ]4 C
152.                         }
     , q; G# x) c$ L
153.         }
     
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     : j. e) l4 I$ u2 F
155. }
     
156. 
     - R! W) q# E2 z  g
157. void USART1_IRQHandler(void)
     * C0 Z' d6 o, b, L$ I
158. {
     ' o/ w6 ^! d/ W* B
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     
160.         {
     7 {1 [2 {2 h/ s; L' h2 S* C# T
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     
162.                 USART1->DR = car;
     9 _2 Z+ X. G( D1 j
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
       ^7 s8 D* o, k' @# f' x/ H
165.         }
     
166.        
     
167.         if(USART1->SR & USART_SR_RXNE)
     ' N! b6 f) F4 R' Q
168.         {
     1 {9 G5 M8 F6 ~! t, Z3 R
169.                 volatile int8_t com_data;
     4 I, f; p3 K) Z' R; V
170.                 com_data = USART1->DR;
     ' O7 U+ d' u4 C7 G% T
171.         }
     
172. }

复制代码

3 Y( v1 }, Y2 X$ W4 j' V4 |————————————————
0 o2 r5 ^* R% \. `) P% s版权声明：家安

7 C, X. ]. E2 ?
' r1 V% ]8 f+ n& x  D3 {