通过中断方式读取电压，不过最后楼主读取参考电压失败，还没有找到错误，所以读取的电压只能十六进制显示，
2 e  C3 P9 W. h- a# k/ Z# W: _
& Y& O+ ]: R! ^; C4 w! V本文的介绍按照一般流程来走：
1，串口的初始化
2 @6 `6 K" D2 C2 P2，ADC初始化
3，中断初始化
4 |% n+ V  Y& {8 Y4，编写中断函数
5，编写主函数

接下来详细介绍：

; o5 C: E! K  K% d1，串口的初始化：
" X. _" O4 }: b. q5 R4 F% N% R$ u

1. void usart_init()
   9 ^" N( i3 @2 B- j
2. {
   8 x5 z2 H5 W; r2 t$ U- a9 ?: b
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.       
    
11.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    " d8 P: L) C' D  U# C: m
12.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    ) P" ], O) E  B2 O5 \* |
13.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    ) Y8 ~* B# q: v4 c
14.     GPIO_Init(GPIOA,&Uart_A);   
    
15.        
    
16.         USART_InitTypeDef Uart;  
    
17.       
    
18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
    
19.     Uart.USART_BaudRate = 115200;  
    
20.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    
21.     Uart.USART_Mode = USART_Mode_Tx;  
    . e7 b, G- n. V. N
22.     Uart.USART_Parity = USART_Parity_No;  
    
23.     Uart.USART_StopBits = USART_StopBits_1;  
    % `8 R2 {+ W2 l
24.     Uart.USART_WordLength = USART_WordLength_8b;  
    , q5 Y4 w- H* V* L! I% O. O
25.     USART_Init(USART1,&Uart);  
    
26.       
    
27.     USART_Cmd(USART1,ENABLE);  
    
28.     USART_ClearFlag(USART1,USART_FLAG_TC);
    
29. }

复制代码

5 ^1 M; s. v' r
关于本段代码，我前面写的文章STM32基础设计（3）有详细讲解，此处不再赘述。
2 t( z% E, |( A. l* U( J# q

2，ADC初始化

1. typedef struct
   
2. {//配置ADC的模式，一个ADC是独立模式，2个是双模式
   0 ]; L# s2 c: \( {0 M8 ^
3.   uint32_t ADC_Mode;                      /*!< Configures the ADC to operate in independent or
   
4.                                                dual mode.
   
5.                                                This parameter can be a value of @ref ADC_mode */
   
6. //配置ADC是否使用扫描，单通道不扫描，多通道扫描
   
7.   FunctionalState ADC_ScanConvMode;       /*!< Specifies whether the conversion is performed in
   
8.                                                Scan (multichannels) or Single (one channel) mode.
   : A' y1 j# b- g7 U! {2 d* {
9.                                                This parameter can be set to ENABLE or DISABLE */
   6 I+ c% ^. Y9 Y. P( u/ j7 W" U
10. //配置ADC是单次转换还是连续转换
    ! E0 |2 X* d  F$ r
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. //外部触发选择
    5 C3 j3 l* T# E
15.   uint32_t ADC_ExternalTrigConv;          /*!< Defines the external trigger used to start the analog
    
16.                                                to digital conversion of regular channels. This parameter
    6 b( [; g* s% M7 V- _7 u
17.                                                can be a value of @ref ADC_external_trigger_sources_for_regular_channels_conversion */
    2 M# A8 J& B' x2 p% O1 S! l; Q: w
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 */
    
21. //ADC转换的通道数目
    , b2 N2 ]  a, N
22.   uint8_t ADC_NbrOfChannel;               /*!< Specifies the number of ADC channels that will be converted
    
23.                                                using the sequencer for regular channel group.
    ! ~2 b' s% A% n2 V* J
24.                                                This parameter must range from 1 to 16. */
    ! ^( H: x; F9 @, Q9 L$ L
25. }ADC_InitTypeDef;

复制代码

下面粘贴代码：

; Q6 {) {$ {% X& ]7 E

1. void Adc_Init()
   * S, K5 s$ q, ~0 G" B
2. {
   
3.         ADC_InitTypeDef adc;//定义ADC结构的变量
     r9 I( E. i  C' d" L; o
4.         GPIO_InitTypeDef io_b;//定义串口结构体变量 ，开发板上的电源接的是GPIOB端口的 1引脚，查数据手册，其为ADC1的9通道
   4 H0 o5 i/ d' E1 D5 v0 `6 ~8 y# k2 J5 ]
5.        
     s/ S. i: ^6 h- J1 B& g8 v
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);//开时钟（即把心脏激活）
   / t6 t7 U. A8 O' h  x
7.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
   
8.        
   ' i6 c6 @4 ?9 g) X
9.         io_b.GPIO_Pin = GPIO_Pin_1;//设置端口引脚为 引脚1
   " q3 Z. o7 y/ w
10.         io_b.GPIO_Mode = GPIO_Mode_AIN;//设置为输入模式
    
11.         io_b.GPIO_Speed = GPIO_Speed_50MHz;//最高速率为50MHz
    
12.         GPIO_Init(GPIOB,&io_b);初始化引脚
    ( _% c& X  F7 N1 s! p
13.         ADC_DeInit(ADC1);先将外设ADC1的全部寄存器重设为默认值 ADC_TempSensorVrefintCmd(ENABLE);谁能外部参照电压（勿忘）
    
14.         adc.ADC_Mode = ADC_Mode_Independent;设置ADC为独立模式
    / ~- E1 L0 u9 H9 ?, G3 \
15.         adc.ADC_ScanConvMode = ENABLE;使能扫描模式
    
16.         adc.ADC_ContinuousConvMode = ENABLE;使能连续扫描
    $ l5 t0 {+ h) P3 G! Z! y# O
17.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发
    
18.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据右对齐
    
19.         adc.ADC_NbrOfChannel = 2;来制定用几个ADC通达（勿忘）
    . o8 \; r; J1 F, j; B% ]# J4 w& {
20.         ADC_Init(ADC1,&adc);初始化ADC寄存器
    
21.        
    
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);制定用哪个ADC转换、第几个通道，转换的顺序、转换的周期
    2 n8 ]9 j! R0 g4 Q. O
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
24.         //这里需要根据数据手册来设定通道，数据手册上会说明那个引脚对应那个通道，外接电源接到那个引脚上就可以了，必须按照数据手册的要求来，不然肯定会出错，博主在这里就有一个很大很大的教训，望读者谨记
    
25.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);打开ADC中断
    + Q2 l+ z0 \; w
26.         ADC_Cmd(ADC1,ENABLE);使能ADC1
    
27.         ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    + q1 b: j, g8 F# y
28.         while(ADC_GetResetCalibrationStatus(ADC1));等待校准寄存器复位完成
    
29.        
    , Y3 J6 b1 O# @6 f6 B
30.         ADC_StartCalibration(ADC1);开始ADC1校准
    9 A5 Q2 y1 P  ?  L, @
31.         while(ADC_GetCalibrationStatus(ADC1));等待ADC1校准完成
    ' a. }8 i2 r4 I* u1 n6 T. H* |7 X
32.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);使能指定的ADC1的软件转换启动功能
    + `* o( s: J! e
33. }

复制代码

3.中断初始化
" b! [2 V! H; C" i% {2 n

1. void adc_nvic_init()
   
2. {
   
3.        
   1 a7 V  t' P" W7 h( P9 W( p) k4 \
4.         NVIC_InitTypeDef nvic;定义中断结构体
   . f4 c- ]' \0 l5 X' v& |0 L# p
5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   " R7 h. K* W/ @( w
6.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;制定专断通道
   / o: N4 ]% o! t1 [$ l  ^
7.         nvic.NVIC_IRQChannelCmd = ENABLE;使能中断
   
8.         nvic.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级
   # @- K5 N$ ~$ o
9.         nvic.NVIC_IRQChannelSubPriority = 1;子优先级
   / e/ N, m7 ?! k
10.         NVIC_Init(&nvic);初始化
    4 h1 M$ G% L( e1 F' ~# [* O
11.        
    
12.         NVIC_InitTypeDef usart1;定义中断结构体
    * t' e- s/ E+ i4 o' p
13.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
    4 n: u/ {' ^2 J/ ^' A
14.         usart1.NVIC_IRQChannel = USART1_IRQn;指定中断通道
    # w2 ?% y2 \# n- f/ X9 S( ~
15.         usart1.NVIC_IRQChannelCmd = ENABLE;设能中断通道
    7 _& a5 V1 P3 k& W! Y- u: q
16.         usart1.NVIC_IRQChannelPreemptionPriority = 0;抢占优先级
    / s$ [" p, W" h8 S5 ?
17.         usart1.NVIC_IRQChannelSubPriority= 0;子优先级
    
18.         NVIC_Init(&usart1);中断初始化
    
19. }

复制代码

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

1. void ADC1_2_IRQHandler()
   3 R9 M9 q* O# e' m  I
2. {
   
3.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)这里使用来判断，如果已经转换完成EOC位为1，具体请查看参考手册ADC状态寄存器ADC_SR的eEOC位
   8 V9 C! C" f$ |7 D
4.         {if(count_1%2 == 0){代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的。具体见下面的解释
   ! Q+ n2 \! r+ s$ R% m
5.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
   
6.                 count_1++;
   ! T* \' u1 R1 L8 Q/ [0 z
7.         }else
   ( Z( v+ ?3 o1 L# M% P
8.                         {
   + l% x# g8 t6 ^- J9 k$ H( ?7 g
9.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
   % t2 V2 B* T0 K) k! ?, j9 B
10.                                 //ADC_ConvertedValue_1 = ADC1->DR;
    
11.                                 count_1++;
    
12.                         }
    
13.         }
    , G$ U6 V3 g' A; v- y: p  A: @8 E3 ^! v
14.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
    
15. }
    
16. 
    
17. void USART1_IRQHandler(void)
    
18. {
    . P: W( f" A2 O/ T, G2 u
19.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))判断是否可以发送数据
    
20.         {
    ! M1 E5 m. A6 E! M/ g" G2 U
21.                 USART1->CR1 &= ~USART_CR1_TXEIE;在这里笔者也碰到了问题，详见下文
    . P$ Y; a; A5 y+ F! z1 [5 V) }7 r
22.                 USART1->DR = car;
    
23.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
    0 q/ `8 B: t1 c6 G+ F4 Q9 y3 G
24.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
    9 a1 R9 S) j* n" J& F2 P
25.         }
    6 r8 e2 k+ }5 n4 r/ Y- |3 p- a
26.        
    : R* G( V9 v2 }& ]$ _1 c
27.         if(USART1->SR & USART_SR_RXNE)判断是否可以接收数据
    # M  _" [# [* u2 |
28.         {
    
29.                 volatile int8_t com_data;
    7 ~6 J1 ~/ J/ P8 ?2 k1 H
30.                 com_data = USART1->DR;
    9 v$ W1 ~; j4 P3 _
31.         }
    
32. }

复制代码

在ADC中断服务函数中，代码中的if语句中的嵌套if语句是用来区分外接电源电压和内部参考电压的，因为第一次接受的是外部电源电压，第二次接受的是内部参考电压，所以可以利用奇偶数，即偶数用ADC_ConvertedValue来存放外部电源电压值，奇数时用ADC_ConvertedValue_1来存放参考电压值。但是，笔者发现，这样会失败，经过串口调试发现两次接受到的值都一样，笔者初步认为，可能是ADC的转换速率太快了，具体什么歌情况还不清楚，等下一个基础设计ADC转换（DMA方式）的时候在细究。
+ C9 n  U! A4 [: P9 h5 U
关于那个还要在中断服务函数中再次将TXEIE设置为零，是因为发送中断是通过 打开中断函数（USART_ITConfig）进入的，该函数中已经将CR1寄存器中的TXEIE位置1 的，所以中断服务函数中还要再次清0，以防止再中断。

---------------------------------------------------------------------------------------------------------------------------------
' {1 o) L9 {# i/ G' O* a
5，编写主函数
. k- [% r3 e, q

1. int main()
   * @" \0 T; A* f2 W  C! P0 G
2. {
   
3.         void PrintU16(uint16_t num);
   9 i2 B. }+ p4 d+ T3 Z' Z$ H5 y8 b
4.         void PrintHexU8(uint8_t data);
   
5. 
   
6.         Adc_Init();
   * ?/ k1 B3 L9 K4 S3 A9 r, t$ m
7.         adc_nvic_init();
   ! m* l( Z( |4 B4 A0 E5 v
8.         usart_init();
   . S0 [0 n4 ]( D: e
9.         while(1)
   
10.         {
    . T6 G8 b7 m! D
11.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );参考电压是1.2f通过比例关系算出实际电压。
    
12.                 PrintU16(num);
    8 z) ?1 e5 t2 ~1 _
13.                 delay(1000);
    
14.         }
    ! q: w* l% p& Z& ]2 o
15. }

复制代码

笔者并没有计算出准确的电压值，只是采集到两个电压值，笔者猜测，可能是因为ADC的转换速率太快，导致笔者的  通过奇偶数来区分内部电压和外部电压不管用了，笔者还在思考解决方式，如果读者有好的方法，请指教。
, }/ u1 Q/ C6 g; U6 i2 \  ]
4 a/ |# a" F) v5 x" c+ c. E
本文到此结束，下面是完整代码：
7 x+ N& Y4 @1 \* {. X

1. #include<stm32f10x.h>
   . y5 ?6 y6 E' d* O
2. #define uint unsigned int
   
3. #define uchar unsigned char
   4 D  C, M' H4 h; o
4.        
   2 o- o% f0 K* u! n
5. char car;
   
6. static char count_1=0;//当做奇偶数
   6 n' c/ T8 c4 c* p1 Y
7. uint16_t ADC_ConvertedValue;//存放电源电压
   
8. uint16_t ADC_ConvertedValue_1;//存放内部参照电压
   
9.         static uint16_t num=0;
   
10. void delay(uint n)
    
11. {
    
12.         int i,j;
    
13.         for(i=0;i<n;i++)
    ( J/ }3 f0 ?" h. u
14.         for(j=0;j<8500;j++);
    
15. }
    1 \& k. Z7 f0 v0 z9 C$ Z
16. 
    
17. void Adc_Init()
    
18. {
    : O+ d3 |$ X5 a0 U7 N, e5 }
19.         ADC_InitTypeDef adc;
    * ^! u& O# U2 v. ]
20.         GPIO_InitTypeDef io_b;
    : G; s& ?; }4 }" g
21.        
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    7 l) x, r9 s; ~! k* b' A0 q
23.         RCC_ADCCLKConfig(RCC_PCLK2_Div6);
    ' A( _1 w+ N. R
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;
    . }- J; K. {% k* p% c
28.         GPIO_Init(GPIOB,&io_b);
    
29.        
    
30.         ADC_DeInit(ADC1);
    $ c' U7 n6 O9 [6 W  e5 H; M
31.         ADC_TempSensorVrefintCmd(ENABLE);
    ! j) R+ x( h& @$ d% \1 \% h
32.         adc.ADC_Mode = ADC_Mode_Independent;
    
33.         adc.ADC_ScanConvMode = ENABLE;
    7 ?0 e- u' @* Q0 E: K7 K+ V7 G! |
34.         adc.ADC_ContinuousConvMode = ENABLE;
    
35.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    + A3 j8 F5 @2 D( m' ?2 N* L
36.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    % z7 T2 x" Q: {, d
37.         adc.ADC_NbrOfChannel = 2;
    
38.         ADC_Init(ADC1,&adc);
    
39.        
    
40.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    
41.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
    
42.        
    - P8 g8 t' A+ T3 \6 Y6 U* Z0 ~6 O
43.         ADC_ITConfig(ADC1,ADC_IT_EOC,ENABLE);
    
44.         ADC_Cmd(ADC1,ENABLE);
    1 x. g; V+ c0 J& K4 N5 s
45.         ADC_ResetCalibration(ADC1);
    0 z( E) `4 H; g
46.         while(ADC_GetResetCalibrationStatus(ADC1));
    
47.        
    
48.         ADC_StartCalibration(ADC1);
    
49.         while(ADC_GetCalibrationStatus(ADC1));
    # U! o1 O4 \( ]7 R0 h7 w, U
50.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
    * \7 A2 e& l, ^) C  `' Z9 k
51. }
    / i8 C2 d: \" ^9 ]4 F4 x# r6 r0 L* M! W) W
52. 
    # L2 N/ N& x& s
53. void adc_nvic_init()
    
54. {
    ) P$ g* k  A: W* B$ b, N
55.        
    , M5 S7 l( W$ K8 t2 |2 v$ Q
56.         NVIC_InitTypeDef nvic;
    
57.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
58.         nvic.NVIC_IRQChannel = ADC1_2_IRQn;
    
59.         nvic.NVIC_IRQChannelCmd = ENABLE;
    8 u1 V8 T# I  K# a# Y& a$ u
60.         nvic.NVIC_IRQChannelPreemptionPriority = 1;
    0 d4 L7 p. h6 X) Y, Z% H
61.         nvic.NVIC_IRQChannelSubPriority = 1;
    
62.         NVIC_Init(&nvic);
    
63.        
    4 I$ _1 B3 ?8 c2 }, B6 J
64.         NVIC_InitTypeDef usart1;
    
65.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
66.         usart1.NVIC_IRQChannel = USART1_IRQn;
    
67.         usart1.NVIC_IRQChannelCmd = ENABLE;
    
68.         usart1.NVIC_IRQChannelPreemptionPriority = 0;
    
69.         usart1.NVIC_IRQChannelSubPriority= 0;
    
70.         NVIC_Init(&usart1);
    
71. }
    
72. 
    
73. void usart_init()
    
74. {
    
75.          GPIO_InitTypeDef Uart_A;  
    0 F6 _  j% {; @- Q
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;  
    0 x5 T9 x% Z$ p; Y6 a& g5 ~& Q+ g: P
81.     GPIO_Init(GPIOA,&Uart_A);  
    ( ~5 B0 A% E4 x
82.       
    
83.     Uart_A.GPIO_Pin = GPIO_Pin_10;  
    
84.     Uart_A.GPIO_Speed = GPIO_Speed_50MHz;  
    / \. {7 g* V% x
85.     Uart_A.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
86.     GPIO_Init(GPIOA,&Uart_A);   
    + c: m7 J% C4 [- j' x8 p+ k
87.        
    
88.         USART_InitTypeDef Uart;  
    
89.       
    0 y1 J/ t" X7 ?2 I8 h) r
90.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);  
      h# [- X% c, U' n4 d
91.     Uart.USART_BaudRate = 115200;  
    
92.     Uart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  
    ( m, F2 A' @/ {9 N% p! ?  b6 N5 M
93.     Uart.USART_Mode = USART_Mode_Tx;  
    
94.     Uart.USART_Parity = USART_Parity_No;  
    # J9 }- P/ _# K* |: R6 N/ d( F1 R
95.     Uart.USART_StopBits = USART_StopBits_1;  
    
96.     Uart.USART_WordLength = USART_WordLength_8b;  
    
97.     USART_Init(USART1,&Uart);  
    
98.       
    
99.     USART_Cmd(USART1,ENABLE);  
    
100.     USART_ClearFlag(USART1,USART_FLAG_TC);
     
101. }
     
102. int main()
     / f0 q+ j2 ^- w2 \7 d
103. {
     
104.         void PrintU16(uint16_t num);
     
105.         void PrintHexU8(uint8_t data);
     
106. 
     
107.         Adc_Init();
     1 M* u# b4 ^# M, W
108.         adc_nvic_init();
     
109.         usart_init();
     : C/ n8 e, X% {* _. E3 Q. _/ D
110.         while(1)
     * \, b+ q. {& e' X' E, p
111.         {
     
112.                 num = (uint16_t)(2.0f* ADC_ConvertedValue/ADC_ConvertedValue_1 *1.2f*100 );
     $ b7 N' q( P4 k
113. 
     
114.                 PrintU16(num);
     
115.                 delay(1000);
     
116.         }
     
117. }
     " u+ ?$ z$ s5 ^8 b
118. 
     
119. void PrintU16(uint16_t num)
     
120. {
     
121.         void PrintHexU8(uint8_t data);
     
122.         uint8_t w5,w4,w3,w2,w1;
     + ^4 [# `* X) ~  T, X
123.         w5 = num % 100000/10000;
     
124.         w4 = num % 10000/1000;
     1 @* T$ H" `1 i1 I0 J9 I' s
125.         w3 = num % 1000/100;
     
126.         w2 = num % 100/10;
     
127.         w1 = num % 10;
     
128.         PrintHexU8('0' + w5);
     
129.         PrintHexU8('0' + w4);
     : o1 L. Q% x( N1 ]) ~2 m
130.         PrintHexU8('0' + w3);
     & P( d+ V0 y: W. U1 i/ k
131.         PrintHexU8('0' + w2);
     ; L/ {* q% L+ k: e/ f0 q4 U' w
132.         PrintHexU8('0' + w1);
     
133. }
     
134. 
     
135. void PrintHexU8(uint8_t data)
     
136. {
     
137.         car = data;
     
138.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     / T" j" M7 n) E" L
139.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);//打开发送中断
     
140. }
     % q8 s' s* ^7 R$ l
141. 
     
142. void ADC1_2_IRQHandler()
     
143. {
       m! m% A+ \6 f/ |0 S
144.         if(ADC_GetITStatus(ADC1,ADC_IT_EOC) == SET)
     $ W, X1 h" |6 f3 |( n; T/ j' m
145.         {if(count_1%2 == 0){
     
146.                 ADC_ConvertedValue = ADC_GetConversionValue(ADC1);
     
147.                 count_1++;
     . S1 A# c% u# w/ t6 m/ ]; H
148.         }else
     % u, p" v' g% b& @+ m* C2 B1 ~
149.                         {
     $ u% z6 ^% s+ L: H5 D
150.                                 ADC_ConvertedValue_1 = ADC_GetConversionValue(ADC1);
     1 b% Y; P7 q7 @" k' K
151.                                 count_1++;
     $ M# c; }8 N3 |9 W. }
152.                         }
     
153.         }
     - v- T% t/ G7 \; P8 u
154.         ADC_ClearITPendingBit(ADC1,ADC_IT_EOC);
     : k& B' P" w5 O' X4 W6 l. [
155. }
     
156. 
     7 n9 `: o. G) Q7 _3 q- z- b( c
157. void USART1_IRQHandler(void)
     0 ?7 F! v7 C1 J; v: Y9 P; h& K
158. {
     
159.         if(USART_GetFlagStatus(USART1,USART_FLAG_TXE))
     6 Q& l( _) f. c3 y
160.         {
     5 f1 W2 B  M0 h8 Y
161.                 USART1->CR1 &= ~USART_CR1_TXEIE;
     
162.                 USART1->DR = car;
     & U$ i( N$ d9 `4 u8 `+ \; e& K. p
163.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TXE) == RESET);
     ; \8 _8 @; G; A1 B4 c# }2 B
164.                 //USART1->CR1 &= ~USART_CR1_TXEIE;
     . w& R2 J, v$ L5 B2 s
165.         }
     6 n* f" v8 {9 L* z5 c; J1 Y/ ~; U
166.        
     
167.         if(USART1->SR & USART_SR_RXNE)
     1 \6 r; d& u- b* `- F6 F( B
168.         {
     & J) b& X  i" d8 [! `6 c& z
169.                 volatile int8_t com_data;
     4 t" w, X1 i8 H# z4 x9 }
170.                 com_data = USART1->DR;
     
171.         }
     
172. }

复制代码

5 b* h$ L) X% Y1 D$ C————————————————
版权声明：家安