通过中断方式读取电压，不过最后楼主读取参考电压失败，还没有找到错误，所以读取的电压只能十六进制显示，
4 h6 Q7 v0 b3 w; q; {- n/ d
2 t) q8 Y* R+ M( R4 L* p本文的介绍按照一般流程来走：
" p/ _9 J" T) d/ \1，串口的初始化
2，ADC初始化
3，中断初始化
4，编写中断函数
; B' i0 V" w$ |! ?+ u- _0 r5，编写主函数
8 H( d' n# J0 C3 P) Y
接下来详细介绍：
8 p) d( ~2 j1 U" @
1，串口的初始化：

1. void usart_init()
   , V: o1 ?. i& @& l' t; E& i$ ?
2. {
   7 L0 y3 |6 C  M. i  x! }& X2 A
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;  
   6 U2 ~. r' G/ N
8.     Uart_A.GPIO_Mode = GPIO_Mode_AF_PP;  
   
9.     GPIO_Init(GPIOA,&Uart_A);  
   , ~7 a1 ^+ L8 f: H3 W
10.       
    
11.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    ; Q+ p: A  r# ^1 I* v: B! Y5 f, w
12.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    
13.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
14.     GPIO_Init(GPIOA,&Uart_A);   
    
15.        
    ( `" P2 a! c+ A9 T/ n5 \. G7 N
16.         USART_InitTypeDef Uart;  
    
17.       
    ! o' p: k# e: l$ ?6 X
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    4 o/ X2 j+ {/ Q4 |; u
19.     Uart.USART_BaudRate = 115200;  
    
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
21.     Uart.USART_Mode = USART_Mode_Tx;  
    
22.     Uart.USART_Parity = USART_Parity_No;  
    & `- E, ^6 h$ N! ]! y+ w& `  T
23.     Uart.USART_StopBits = USART_StopBits_1;  
    ) O: n# p+ D/ f' `8 N) h
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    
25.     USART_Init(USART1,&Uart);  
    5 Z6 Z& w2 Z! V+ ^- j( w5 b' |
26.       
    % R, Z! [5 N( n/ h* T2 ^5 C3 v* D
27.     USART_Cmd(USART1,ENABLE);  
    
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
    5 x- ?% {5 e8 s+ g; k' |
29. }

复制代码

关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。
6 f% U( m& x- b/ v" {' t
) D" d" Q; X! B7 u
, A7 P7 D0 l2 I( v+ @2，ADC初始化

1. typedef struct
   1 `+ v& s1 G2 g7 }6 S0 o; G4 E0 x8 b6 R% P
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   
4.                                                dual mode.
   2 ?9 v6 F$ Z, \% f& [
5.                                                This parameter can be a value of @ref ADC_mode */
   
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   0 Y. I, k- d6 ^% W! x% }$ y
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   
8.                                                Scan (multichannels) or Single (one channel) mode.
   4 o, o# O$ a4 R
9.                                                This parameter can be set to ENABLE or DISABLE */
   6 D' W& G$ l: C* n% R
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. */
    
14. //外部触发选择
    ; f# V7 R6 c& B4 d7 v* q$ i
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    1 p% o1 z9 t' u- v. n  B+ l6 o; B
16.                                                to digital conversion of regular channels. This parameter
    ! u4 E: ~; }9 s# V4 W' U) u# D
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    
18. //转换结果数据对其方式
    + _& x) R8 k+ E: a( B: E
19.   uint32_t ADC_DataAlign;                 /*!< Specifies whether the ADC data alignment is left or right.
      g8 N- x# P- l/ L
20.                                                This parameter can be a value of @ref ADC_data_align */
    * q7 r4 r# p- N' c5 |8 X
21. //ADC转换的通道数目
    # T: k& r+ `0 |( Y( K* u. a
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    ( u" w& K1 W( A0 A, \, v) t- h
23.                                                using the sequencer for regular channel group.
    & Y, \3 n8 c/ J4 E: F- |% ?
24.                                                This parameter must range from 1 to 16. */
    
25. }ADC_InitTypeDef;

复制代码

下面粘贴代码：
: X: |; @0 Z. M- i2 D+ Z
# |8 P: W3 |0 C5 J

1. void Adc_Init()
   
2. {
   2 Y  J1 ?* o6 W0 P! L
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
   
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   
5.        
   
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
   / a# S2 z# U8 g3 q
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   
8.        
   
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    1 Y+ ]- S. [3 [$ e' g% Y# N
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    8 V" u! r! O, M
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    & D2 y$ D  y: i7 ^3 [: C6 g
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
    
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    
16.         adc.ADC_ContinuousConvMode = ENABLE;使能连续扫描
    8 C3 j; n; M) z' b- u4 t& H
17.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发
    
18.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据右对齐
    3 g4 {" |! P, _. G1 n' ~7 i% `4 M
19.         adc.ADC_NbrOfChannel = 2;来制定用几个ADC通达（勿忘）
    
20.         ADC_Init(ADC1,&adc);初始化ADC寄存器
    
21.        
    & @6 G$ V7 e! A4 y6 [. P5 C
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    ' e* X$ o( Q2 k$ S
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    3 H7 S5 h* U7 w- ~' u4 F9 ~, p7 a
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    / D7 Y  W: G: c+ G/ l; @
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    + y/ K5 {+ U7 [0 \7 h% q
29.        
    # @0 b9 G6 _& K& j' R
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    5 _4 r' w; q# o8 i2 W# q: e" L
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    " T, Q, g- s  V
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    
33. }

复制代码

3.中断初始化
  b! K, v; ]8 G7 \; n  B3 f0 j

1. void adc_nvic_init()
   : W  G5 N# \5 K% f* |4 J
2. {
   
3.        
   
4.         NVIC_InitTypeDef nvic;定义中断结构体
   
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   . n/ c& P, k. _) n$ f
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   4 s  _+ C& `# I  e
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   
10.         NVIC_Init(&nvic);初始化
    0 F4 j4 J& F/ x4 \1 ]- |$ S
11.        
    4 O" r/ s( V5 Z: L) L( ~
12.         NVIC_InitTypeDef usart1;定义中断结构体
    
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    % D' }! h$ g6 |
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    & G* u; O! {" [
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    / T$ j$ O" a) N
18.         NVIC_Init(&usart1);中断初始化
    
19. }

复制代码

4，编写中断函数
先粘贴代码：

1. void ADC1_2_IRQHandler()
   / I8 g# L# D) K2 B
2. {
   ' K; S* F& @. W9 F1 K
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   & r: c& H: v" b; }1 `( G
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   / X) k: q9 ?% c  R' p5 X
6.                 count_1++;
   
7.         }else
   
8.                         {
   
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    
11.                                 count_1++;
    
12.                         }
    
13.         }
    ' f% M8 N2 s' c
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    
15. }
    
16. 
    
17. void USART1_IRQHandler(void)
    + k- j( p2 L+ \' v5 e, u* |9 y
18. {
    + @% \" d% K# m/ n1 {
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    
20.         {
    
21.                 USART1->CR1 &= ~USART_CR1_TXEIE;在这里笔者也碰到了问题，详见下文
    
22.                 USART1->DR = car;
    $ r8 C2 x+ s3 d+ e- ^
23.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    
24.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
    ( k, f9 w  q5 g1 @$ g
25.         }
    
26.        
    
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    , g4 }- s1 `# z" x* N- u. I# o) `
28.         {
    
29.                 volatile int8_t com_data;
    2 N  N% Z" h5 p, ~
30.                 com_data = USART1->DR;
    
31.         }
    
32. }

复制代码

4 }5 E0 b5 t$ `8 C9 e在ADC中断服务函数中，代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的，因为第一次接受的是外部电源电压，第二次接受的是内部参考电压，所以可以利用奇偶数，即偶数用ADC_ConvertedValue来存放外部电源电压值，奇数时用ADC_ConvertedValue_1来存放参考电压值。但是，笔者发现，这样会失败，经过串口调试发现两次接受到的值都一样，笔者初步认为，可能是ADC的转换速率太快了，具体什么歌情况还不清楚，等下一个基础设计ADC转换（DMA方式）的时候在细究。
# Q! L/ T/ k5 @0 ^- V
4 N0 k5 @, [7 t2 {关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。
! f2 M3 G7 b  h! Q6 N
---------------------------------------------------------------------------------------------------------------------------------
. C% Y# l, u! a) b# ^& w* ?( d
5，编写主函数

1. int main()
   7 H) Q- Y0 p# J0 a3 |% u& D
2. {
   
3.         void PrintU16(uint16_t num);
   
4.         void PrintHexU8(uint8_t data);
   : \7 X  g- M' o" U
5. 
   
6.         Adc_Init();
   
7.         adc_nvic_init();
   
8.         usart_init();
   
9.         while(1)
   7 \$ I( ]( T  F" Y! [2 y8 S
10.         {
    
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    3 b$ b5 n3 }! ^7 I0 h' @. _% Q; z
12.                 PrintU16(num);
    
13.                 delay(1000);
    
14.         }
    
15. }

复制代码

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

8 ^- y; x$ |' T
4 D6 Y% I" p, N) `6 g3 [本文到此结束，下面是完整代码：

1. #include<stm32f10x.h>
   6 C- q0 k# X/ e$ v/ i% o
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4.        
     P8 ~5 \2 ~' O2 d7 K8 d
5. char car;
   9 k# S% J$ ~# H: X
6. static char count_1=0;//当做奇偶数
   8 s" [, Q% p% ~, ^" A" I" R
7. uint16_t ADC_ConvertedValue;//存放电源电压
   ! j, _. q- y" A1 N- w
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   5 M; r7 K* x0 ^# q8 G% }# S
9.         static uint16_t num=0;
   % ]; |  w) F- n1 d% |
10. void delay(uint n)
    
11. {
    
12.         int i,j;
    1 N7 z) E) a1 T4 l
13.         for(i=0;i<n;i++)
    
14.         for(j=0;j<8500;j++);
    
15. }
    * ]7 Z) x  a+ o. T  j' H; {5 w
16. 
    
17. void Adc_Init()
    8 J5 e# P% J& a6 f0 B: Z4 J, f, s
18. {
    6 l9 ~+ e) g+ `7 g" M: Y" F7 ~% G
19.         ADC_InitTypeDef adc;
    
20.         GPIO_InitTypeDef io_b;
    : N5 O) X7 c) D) ]" n+ g$ h
21.        
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    
24.        
    + x; F! g! P3 i: M% ~3 O' ]
25.         io_b.GPIO_Pin = GPIO_Pin_1;
    1 @; H9 w& K% e
26.         io_b.GPIO_Mode = GPIO_Mode_AIN;
    / E1 `# ?9 \% ?0 `
27.         io_b.GPIO_Speed = GPIO_Speed_50MHz;
    
28.         GPIO_Init(GPIOB,&io_b);
    
29.        
    3 ]9 y+ f) [: T; V
30.         ADC_DeInit(ADC1);
    + L9 a6 ~" s, W; m
31.         ADC_TempSensorVrefintCmd(ENABLE);
    
32.         adc.ADC_Mode = ADC_Mode_Independent;
    
33.         adc.ADC_ScanConvMode = ENABLE;
    
34.         adc.ADC_ContinuousConvMode = ENABLE;
    
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    2 K8 @: X: b3 e  W- _
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    
37.         adc.ADC_NbrOfChannel = 2;
    
38.         ADC_Init(ADC1,&adc);
    2 |6 \% _6 y: N# C# J  |
39.        
    
40.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    9 a$ A" X9 C# g
41.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
42.        
    ( v5 Z, w: k& \3 A( z# ~% O
43.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);
    : p" s! s6 W& r
44.         ADC_Cmd(ADC1,ENABLE);
    
45.         ADC_ResetCalibration(ADC1);
    
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    5 B0 H$ ^# l. B
47.        
    & H& w8 S+ I2 ~8 S1 t) ]
48.         ADC_StartCalibration(ADC1);
    
49.         while(ADC_GetCalibrationStatus(ADC1));
    / t- `  _7 |' K% i
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    
51. }
    
52. 
    
53. void adc_nvic_init()
    
54. {
    2 G6 j4 U, l% k5 ?; `9 f( Y
55.        
    
56.         NVIC_InitTypeDef nvic;
    + d) g# t" q! s" H
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    : m2 C" B5 r0 E! S! K
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    ; h7 w; ]' r/ @" R, d  Z- x
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    : U1 C6 o" J) F
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    
62.         NVIC_Init(&nvic);
    : r- |) R. t) h" D+ y' r, D
63.        
    
64.         NVIC_InitTypeDef usart1;
    
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    2 L$ X1 b8 j: H. D$ B7 H7 Y
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    ' _0 q$ {& Z/ S9 H
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    
70.         NVIC_Init(&usart1);
    
71. }
    " d: R. c' _7 `6 B
72. 
    
73. void usart_init()
    
74. {
    % {; ~1 A: s4 b8 W  Q
75.          GPIO_InitTypeDef Uart_A;  
    4 E) x7 G2 t8 l
76.       
    
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$ \$ Y# B+ J- A+ k% O+ J
81.     GPIO_Init(GPIOA,&Uart_A);  
    
82.       
    - O5 ]7 o( `. F' m, Y. K
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    9 c6 N8 Y2 o/ G. f- ]
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
86.     GPIO_Init(GPIOA,&Uart_A);   
    
87.        
    
88.         USART_InitTypeDef Uart;  
    4 l# j0 u7 F* v& r  f# l
89.       
    1 f, K* ^: v) A: [- x
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    ! }, n. d5 H6 E0 b2 }7 Y( I: z2 W
91.     Uart.USART_BaudRate = 115200;  
    * H- c: I' C) a6 V* k( D
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    , h+ W$ O3 c0 l5 P; }$ [
93.     Uart.USART_Mode = USART_Mode_Tx;  
    + u0 t7 x8 E/ u
94.     Uart.USART_Parity = USART_Parity_No;  
    
95.     Uart.USART_StopBits = USART_StopBits_1;  
    
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    
97.     USART_Init(USART1,&Uart);  
    
98.       
    3 C  S; z; B' @) I3 {, g3 j
99.     USART_Cmd(USART1,ENABLE);  
    
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     2 L8 u( G% V( X* [1 h" n
101. }
     
102. int main()
     + h" \+ G. i: Z' b) D: g: v
103. {
     
104.         void PrintU16(uint16_t num);
     : O0 R% P& |. i5 w0 S
105.         void PrintHexU8(uint8_t data);
     
106. 
     
107.         Adc_Init();
     , ~) F7 Q2 X3 e- ~7 i1 `$ @  o
108.         adc_nvic_init();
     
109.         usart_init();
     
110.         while(1)
     
111.         {
     
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     $ t& z( P3 a* m( X
113. 
     
114.                 PrintU16(num);
     
115.                 delay(1000);
     ; K" J, X1 |7 [: P% a: [
116.         }
     # i3 E/ A3 ?4 V
117. }
     , e$ j# B6 A6 S" F1 ~& z+ O( ~
118. 
     
119. void PrintU16(uint16_t num)
     
120. {
     
121.         void PrintHexU8(uint8_t data);
     
122.         uint8_t w5,w4,w3,w2,w1;
     , e# n! [: ]5 I5 b5 @
123.         w5 = num % 100000/10000;
     % H! K) i  ?. r6 T0 I* |) ?+ P
124.         w4 = num % 10000/1000;
     , _# j! v$ \8 o9 G
125.         w3 = num % 1000/100;
     1 {8 v8 v: J. e) q1 m0 g2 Q0 [+ {
126.         w2 = num % 100/10;
     
127.         w1 = num % 10;
     
128.         PrintHexU8('0' + w5);
     6 y9 U- u" t( L* a' M
129.         PrintHexU8('0' + w4);
     ( M( k) V* F6 I- ~! h  f* u6 t2 T
130.         PrintHexU8('0' + w3);
     
131.         PrintHexU8('0' + w2);
     7 P1 ~% }9 C. N# r! F
132.         PrintHexU8('0' + w1);
     
133. }
     ( S/ F# _5 \2 p& u- ^8 Z
134. 
     
135. void PrintHexU8(uint8_t data)
     7 H, Y! k- c2 e: O' f; N
136. {
     ) N1 {9 y2 W, e9 [3 t
137.         car = data;
     
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     
140. }
     # T1 Y+ M) g* W* K# i  [0 a# E
141. 
     
142. void ADC1_2_IRQHandler()
     1 t) x( m% [7 w+ I6 }3 l; f
143. {
     
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     
145.         {if(count_1%2 == 0){
     ! z9 u3 v% c9 w: t
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     . p8 I: L  S: g
148.         }else
     
149.                         {
     + {5 G3 {  B1 D7 }8 N
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     
151.                                 count_1++;
     ( P0 I$ r9 |  Y5 s& I+ `# Q
152.                         }
     
153.         }
     ! @# ?! V. {, K1 v+ L
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     
155. }
     
156. 
     % E/ g& z6 w# P* z' T* ^- g& [
157. void USART1_IRQHandler(void)
     
158. {
     " k' L( l6 \0 u6 l8 k' `# @9 I
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     8 U* A9 c# G9 e" c; s5 }, \
160.         {
     
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     
162.                 USART1->DR = car;
     
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     9 K. Y* p, d& t3 O& k2 S& S9 ^: b
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
     
165.         }
     
166.        
     7 l" Z( f# j& q; c
167.         if(USART1->SR & USART_SR_RXNE)
     
168.         {
     
169.                 volatile int8_t com_data;
     
170.                 com_data = USART1->DR;
     2 D' X& |. x3 s) ?9 D& x; S
171.         }
     + B5 }& S5 Y& l8 R3 s8 G
172. }

复制代码

————————————————
版权声明：家安
0 G. N; L: s: {* L& r

1 Z, j2 A8 L; ~