本文简单介绍了STM32F103C8，通过DMA方式读取ADC并通过串口中断向电脑端打印出当前电源ADC的值。
7 p  M* v1 T( t$ J$ A( @/ P
  g! D/ J) q1 J: J2 a) {现在先将设计过程的主要步骤介绍如下：
) K6 T# t3 x2 d- }& b- K) a                1，串口配置
$ x9 G. D3 J, R                2，中断配置
                3，DMA配置
                4，ADC配置
                5，中断服务函数
$ b1 N+ ]' t+ \3 G                6，主函数
: a" o* B  ?: z6 t6 O* r' r
       先总结下博主在这次基础设计中犯的错误，在中断初始化函数中，没有将中断通道使能，导致电脑端没有接收到数据，发现后就去检查串口初始化函数了，结果没有发现错误，而是检查了一遍代码才发现错误。发现串口无法工作后，先核查初始化函数，如果问题没有解决，第二步，如果是串口中断方式，接下来检查，中断初始化函数，如果是串口查询方式，接下来检查主函数的串口查询代码。
. ^8 r0 L; p& t7 v( ]7 Q
, A$ u& T5 C8 G" |0 d接下来详细介绍各个步骤：
" X# q6 x; P- w7 ?6 m
1，串口配置

1. void usart_init(void)
   
2. {
   . y2 V- o" N5 u! M# V
3.         GPIO_InitTypeDef GPIO_usart;定义GPIO结构体
   
4.         USART_InitTypeDef USART_usart;定义串口结构体
   
5.        
   $ j! |5 R# P5 Y+ K
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1 ,ENABLE);使能外设时钟
   
7.        
   
8.         GPIO_usart.GPIO_Pin = GPIO_Pin_9;
   
9.         GPIO_usart.GPIO_Mode = GPIO_Mode_AF_PP;
   
10.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    / B5 {2 O' j$ \
11.         GPIO_Init(GPIOA,&GPIO_usart);配置发送口
    % v% a8 I9 U0 G
12.        
    6 [! g. s% D; y; _. T
13.         GPIO_usart.GPIO_Pin = GPIO_Pin_10;
    " K" X9 H+ a3 W+ H& r9 v+ O5 R' K
14.         GPIO_usart.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    ; n4 L6 x1 [2 P3 i' M8 o, @2 p
15.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    6 ?; V- i, w1 F/ d
16.         GPIO_Init(GPIOA,&GPIO_usart);配置接受口
    
17.        
    1 d6 {8 o; y# o& Z
18.         USART_usart.USART_BaudRate = 115200;设置传输波特率
    
19.         USART_usart.USART_WordLength = USART_WordLength_8b;设置串口发送字长
    ' y3 Z9 c- N4 O
20.         USART_usart.USART_StopBits = USART_StopBits_1;设置停止位
    
21.         USART_usart.USART_Parity = USART_Parity_No;不进行奇偶校验
    & B* F# \9 }; ?: Z3 x7 F1 I
22.         USART_usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;硬件流使能
    * S6 {& `% p3 |3 Z* i
23.         USART_usart.USART_Mode = USART_Mode_Tx;设置为发送模式
    
24.         USART_Init(USART1,&USART_usart);初始化串口寄存器
    
25.        
    # B0 T; _# L8 }0 ]% T4 D; b# u- c
26.         USART_Cmd(USART1,ENABLE);串口使能
    
27.         USART_ClearFlag(USART1,USART_FLAG_TC);清除已发送位，防止第一位发不出去
      s  N0 v# k# n
28. }

复制代码

2，中断配置
9 {" O* o4 p/ j/ g5 [

1. void nvic_init(void)
   
2. {
   0 _. h- f- r, C2 P1 B2 I6 A
3.         NVIC_InitTypeDef nvic_usart;定义中断结构体
   9 V8 ~2 W4 |  S" U' ~
4.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   ' J# L/ e8 F+ y' b
5.         nvic_usart.NVIC_IRQChannel = USART1_IRQn;制定中断服务函数通道
   
6.         nvic_usart.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级1
   5 c# Z' _7 J0 H
7.         nvic_usart.NVIC_IRQChannelSubPriority = 0;子优先级0
   
8.         nvic_usart.NVIC_IRQChannelCmd = ENABLE;通道使能
   
9.         NVIC_Init(&nvic_usart);中断寄存器初始化
   ( V, Y6 p- ~$ ], s# i" v9 o3 r4 [
10. }

复制代码

7 v+ Q% |: H3 b" }7 ~6 C3，DMA配置
, ~( Y6 T( I8 F5 N+ l4 Z

1. void dma_init(void)
   " W7 \, T/ T3 F4 V0 e& d/ k
2. {
   # B) H6 X$ ]- ]3 M# @# J
3.         DMA_InitTypeDef dma;定义DMA结构体
   " ^# Z) z3 l/ A! c% b
4.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);打开时钟
   1 h! F- ^& T+ o2 K
5.        
   1 ~6 d/ \6 A' ~" L
6.         DMA_DeInit(DMA1_Channel1);现将DMA，通道1寄存器复位
   , j3 y! _1 W- J# b  j
7.         dma.DMA_PeripheralBaseAddr = (u32)&ADC1->DR;设置外设地址
   
8.         dma.DMA_MemoryBaseAddr = (uint32_t)ADC_Value;设置存储器地址
   1 ?4 d8 {4 R4 B8 v) a4 n0 _
9.         dma.DMA_DIR = DMA_DIR_PeripheralSRC;设置传输方向为 外设到存储器
   2 q. a7 o$ C. B9 f9 i9 Y* [
10.         dma.DMA_BufferSize = 2;数据缓冲为设置为2
    
11.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable;外设地址固定
    % m/ K: ^$ t+ p4 c3 W
12.         dma.DMA_MemoryInc = DMA_MemoryInc_Enable;寄存器地址自增
    
13.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;外设数据位宽度半字
    
14.         dma.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;存储器数据位宽度半字
    ( a7 o/ e2 O( m9 K* @5 v
15.         dma.DMA_Mode = DMA_Mode_Circular;DMA工作在循环模式
    
16.         dma.DMA_Priority = DMA_Priority_High;DMA通道为高优先级
    2 a: {. M4 E' t
17.         dma.DMA_M2M = DMA_M2M_Disable;内存到内存传输使能
    
18.         DMA_Init(DMA1_Channel1,&dma);初始化DMA寄存器
    ' B' e7 P: K) `, \5 B
19.        
      ~. h: [3 K# v9 @  T8 h
20.         //DMA_Cmd(DMA1_Channel1,ENABLE);使能通道1 （笔者把这句放到主函数中了，在这里写也行，只不过是笔者认为放到主函数中便于理解）
    ! G$ h  U) X1 \# R
21. }

复制代码

" n; {" I/ R' u4 M# X
# l1 n& [+ k& ^4，adc配置

1. void adc_init(void)
   
2. {
   0 `% J) K2 U3 h0 f
3.         ADC_InitTypeDef adc;定义adc结构体
   
4.         GPIO_InitTypeDef adc_gpio;定义GPIO结构体
   7 `% }! K( {  P) g9 p& n  Q. i. w
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);使能外设
   - `6 l% q/ N8 L- R4 b" e: t
6.        
   * R- e3 q: _  t8 D/ T& z
7.         adc_gpio.GPIO_Pin = GPIO_Pin_1;
   0 I) I9 x8 `) Z0 x" i/ ?" Y, Y
8.         adc_gpio.GPIO_Mode = GPIO_Mode_AIN;
   
9.         GPIO_Init(GPIOB,&adc_gpio);使能ADC的测试通道
   
10.        
    
11.         ADC_DeInit(ADC1);复位ADC1寄存器
    
12.         ADC_TempSensorVrefintCmd(ENABLE);使能内部参照电压
    # J4 y- v; X( ]/ f0 l1 f0 k
13.         adc.ADC_Mode = ADC_Mode_Independent;ADC工作在独立模式
    
14.         adc.ADC_ScanConvMode = ENABLE;使用扫描模式
    
15.         adc.ADC_ContinuousConvMode = ENABLE;使用连续转换模式
    
16.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;不使用外部触发工作模式
    3 A& d7 U; y; n  D$ G
17.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据设置为右对齐
    * p, U0 H) f* O$ Y2 c& _; d  p  [
18.         adc.ADC_NbrOfChannel = 2;两个转换通道
    
19.        
    3 V5 c3 ^" h& C9 J# S  \7 f
20.         ADC_Init(ADC1,&adc);初始化寄存器
    " R* v5 g  [  {
21.        
    ( N! w7 S; H' z
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);对通道9采样（电源电压）
    $ @1 j2 `( E/ L
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);对通道11采样（参考电压）
    
24.        
    
25.         //ADC_DMACmd(ADC1,ENABLE);ADC 的DMA通道使能
      u2 c4 ~/ Y0 Q6 l
26.        
    ' A" s; P; a8 _; i! g
27.         //ADC_Cmd(ADC1,ENABLE);ADC使能
    6 Y  m3 Q. u- l0 n0 g
28.        
    
29.         //ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    , b. j2 [0 H6 z6 ]( F4 \- D" U* x
30.         //while(ADC_GetResetCalibrationStatus(ADC1));等待复位完成
    ) M% a. }( @* q! ~* v3 d  N
31.        
    ; d6 ]7 H# f. U8 z
32.         //ADC_StartCalibration(ADC1);开始ADC1校准
    8 u. B) h  b, P9 O" Z0 f: E
33.         //while(ADC_GetCalibrationStatus(ADC1));等待校准完成
    
34.        
    
35.         //ADC_SoftwareStartConvCmd(ADC1,ENABLE);ADC1的软件转换使能（注：这些注释的部分我放到主函数里了，放在这里也行，只不过，我感觉我那样便于理解）
    - }' j, G; ^/ u4 w: c9 D
36. }

复制代码

2 c' M" i  m3 C* ~- ]( h: Z
. H- ^& f0 a5 ?! {" j5 k1 p, ]5，中断服务函数
9 J; e3 s5 _- g8 Q8 m) ^$ v

1. void USART1_IRQHandler(void)
   6 ^; _3 o4 v) j) s
2. {
   
3.         if(USART1->SR & USART_SR_TC)判断是否能发送数据
   2 O  \6 y4 e8 a, i0 S7 ]
4.         {
   
5.                 USART1->DR = TxBuff[TxCount++];笔者将转换到的电压值存到TxBuff[0]中了
   ' x/ x5 ^8 [5 s3 V
6.                 if(TxCount == Count)等到传完一次数据，就退出中断
   
7.                 {
   
8.                         USART1->CR1 &= ~USART_CR1_TXEIE;
   6 x2 g1 ]  s! p) A8 w  A6 i" ?+ G
9.                 }
   
10.         }
    
11. }

复制代码

6，主函数

1. int main()
   
2. {
   , N0 M2 H. x: f( g
3.         usart_init();串口初始化
   
4.         nvic_init();中断初始化
   / L5 {$ N) P$ I3 W3 z
5.         dma_init();DMA初始化
   
6.         adc_init();ADC初始化
   6 C- Y- F. ^) K% A- G
7.         DMA_Cmd(DMA1_Channel1,ENABLE);//见上文
   
8.         ADC_DMACmd(ADC1,ENABLE);同上
   
9.        
   + l' w! H5 j3 s3 L" K: v* m2 C8 X
10.         ADC_Cmd(ADC1,ENABLE);同上
    7 s; \4 e) Q% n) J
11.        
    
12.         ADC_ResetCalibration(ADC1);同上
    
13.         while(ADC_GetResetCalibrationStatus(ADC1));同上
    / G: p. \! T3 V: b) m5 O1 y- l
14.        
    6 i3 S; C* q$ @4 c5 i
15.         ADC_StartCalibration(ADC1);同上
    
16.         while(ADC_GetCalibrationStatus(ADC1));同上
    1 y# U0 e2 b6 G5 m$ d8 L
17.        
    
18.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);同上
    
19.         while(1)循环打印电压值
    
20.         {
    6 _* {3 g& {0 M6 E2 I, m
21.                 Voltage_Printf();用于打印电压
    4 k/ X% k. {) O7 q
22.                 //PrintString("\r\nprint data!!\r\n");
    
23.                 delay(1000);延时
    
24.         }

复制代码

6 T9 M6 V" s, d) `

1. void Voltage_Printf(void)
   
2. {
   + A9 S7 G: M9 L: a0 H7 l
3.         Battery = (uint16_t)(2.0f *ADC_Value[0] / ADC_Value[1] *1.2f * 100);根据参考电压按比例计算电源电压
   : R5 a& l& j) W! p' r
4.         PrintString("\r\n当前电压值的一百倍：");
   
5.         PrintU16(Battery);
   9 g4 @* g6 W0 d5 j0 |
6.         PrintString("V");
   4 d8 L8 Z5 G8 v8 X4 R, H( B- ^
7. }

复制代码

下面粘贴完整代码

1. #include<stm32f10x.h>
   
2. 
   6 I( _+ Z- J/ r0 G9 H2 j( z
3. uint16_t ADC_Value[2];
   8 t" F0 e/ t% i  X) k- f) L/ b
4. static uint16_t Battery=0;
   " Z6 f4 E& q5 W) n$ [1 i( Y
5. uint8_t TxCount = 0;
   5 X$ o. X; Q! \6 m/ ~, Y0 j# n( K
6. uint8_t Count = 0;
   ! s) @1 L( {( D6 T) f- Y5 o- }6 n& e
7. static uint8_t TxBuff[250];
   
8. volatile uint8_t RxBuffer[50];
   
9. 
   / A3 j. ^' n2 @/ F1 q8 C
10. void delay(uint32_t n)
    
11. {
    
12.         int i,j;
    & g! H' D# a, l) j  A8 V  p
13.         for(i=0;i<n;i++)
    * B  z* H( v7 p7 Q2 t. P
14.                 for(j=0;j<8500;j++);
    
15. }
    : D; ?$ I4 {+ v" i
16. 
    ' J; d6 E6 D) X: u7 J+ Q  y+ x
17. void usart_init(void)
    8 B- w9 a5 v- s2 x
18. {
    
19.         GPIO_InitTypeDef GPIO_usart;
    3 S! o* L- U; _1 f
20.         USART_InitTypeDef USART_usart;
    
21.        
    
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1 ,ENABLE);
    ; M/ K4 a6 `* f4 d; m4 H' D. y* K
23.        
    
24.         GPIO_usart.GPIO_Pin = GPIO_Pin_9;
    
25.         GPIO_usart.GPIO_Mode = GPIO_Mode_AF_PP;
    , |" T; j9 G8 f# r
26.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    
27.         GPIO_Init(GPIOA,&GPIO_usart);
    0 ~; I! L+ u" y* b: X
28.        
    2 ?; c- L# T9 m( f
29.         GPIO_usart.GPIO_Pin = GPIO_Pin_10;
    2 \' L0 t3 a( Z3 \  F0 ~
30.         GPIO_usart.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
31.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    ) e3 D. V+ P8 q
32.         GPIO_Init(GPIOA,&GPIO_usart);
    
33.        
    
34.         USART_usart.USART_BaudRate = 115200;
    
35.         USART_usart.USART_WordLength = USART_WordLength_8b;
    
36.         USART_usart.USART_StopBits = USART_StopBits_1;
    " A3 K) S0 L: Q2 B2 R& X
37.         USART_usart.USART_Parity = USART_Parity_No;
    
38.         USART_usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    / p5 d; O4 O3 J4 b/ a
39.         USART_usart.USART_Mode = USART_Mode_Tx;
    
40.         USART_Init(USART1,&USART_usart);
    
41.        
    , I; t+ Z0 ]; V, _# R4 s2 A
42.         USART_Cmd(USART1,ENABLE);
    1 Z$ d) `0 `2 f0 h% P
43.         USART_ClearFlag(USART1,USART_FLAG_TC);
    
44. }
    + @# B4 |- F7 M  j6 B1 I: x5 l
45.        
    ( c. U. @0 d- E: M
46. void nvic_init(void)
    ) [1 }2 g+ Y/ ~2 D8 a9 a
47. {
    5 w; W" p3 B* C5 u0 V' Y5 G! H8 l  e
48.         NVIC_InitTypeDef nvic_usart;
    
49.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    4 ]+ i4 P: ^5 }. C) u
50.         nvic_usart.NVIC_IRQChannel = USART1_IRQn;
    * b3 U4 D" e- K( f
51.         nvic_usart.NVIC_IRQChannelPreemptionPriority = 1;
    
52.         nvic_usart.NVIC_IRQChannelSubPriority = 0;
    
53.         nvic_usart.NVIC_IRQChannelCmd = ENABLE;
    
54.         NVIC_Init(&nvic_usart);
    , W& b" k6 \. B" {4 j9 R/ q
55. }
    
56.        
    
57. void dma_init(void)
    
58. {
    
59.         DMA_InitTypeDef dma;
    2 y, u0 g3 s& ^. Q% I
60.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    
61.        
    9 a/ [  Y6 d- d1 {
62.         DMA_DeInit(DMA1_Channel1);
    
63.         dma.DMA_PeripheralBaseAddr = (u32)&ADC1->DR;
    
64.         dma.DMA_MemoryBaseAddr = (uint32_t)ADC_Value;
    
65.         dma.DMA_DIR = DMA_DIR_PeripheralSRC;
    
66.         dma.DMA_BufferSize = 2;
    - |9 ?; T% e$ I$ c2 m
67.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    ' u% j; _! U; [& v1 h
68.         dma.DMA_MemoryInc = DMA_MemoryInc_Enable;
      L, C. A5 h: b$ d  E0 A) }
69.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    % Z: o1 u1 ?% a8 i9 `& ~2 U( X4 z) B
70.         dma.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    & s5 Z' @, V) Z3 J  j
71.         dma.DMA_Mode = DMA_Mode_Circular;
    
72.         dma.DMA_Priority = DMA_Priority_High;
    
73.         dma.DMA_M2M = DMA_M2M_Disable;
    9 r- y# i* H, i( L. j
74.         DMA_Init(DMA1_Channel1,&dma);
    
75.        
    
76.         //DMA_Cmd(DMA1_Channel1,ENABLE);
    ' J+ e3 |; F# {( `0 e3 g5 l
77. }
    
78. void adc_init(void)
    
79. {
    , U+ T2 m9 `# t% z4 F( F8 Y
80.         ADC_InitTypeDef adc;
    
81.         GPIO_InitTypeDef adc_gpio;
    $ P) J/ B( T% W, v
82.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    ( H+ z- K1 k& l* k
83.        
    
84.         adc_gpio.GPIO_Pin = GPIO_Pin_1;
    " Q0 c( R/ i% M; R3 ]4 D$ J
85.         adc_gpio.GPIO_Mode = GPIO_Mode_AIN;
    ( F$ \" S7 P; ^% e, [+ J3 ~: W; O
86.         GPIO_Init(GPIOB,&adc_gpio);
    * X5 {& P1 a2 q7 O& d! a$ r
87.        
    
88.         ADC_DeInit(ADC1);
    2 [6 i7 ^! ~9 u) W" e
89.         ADC_TempSensorVrefintCmd(ENABLE);
    
90.         adc.ADC_Mode = ADC_Mode_Independent;
    
91.         adc.ADC_ScanConvMode = ENABLE;
    ) }: q/ j* v% ~0 N# [6 u
92.         adc.ADC_ContinuousConvMode = ENABLE;
    
93.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    
94.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    6 J! f+ A- y& M9 g! p
95.         adc.ADC_NbrOfChannel = 2;
    
96.        
    / \6 g/ ]& J1 v' Y# H
97.         ADC_Init(ADC1,&adc);
    
98.        
    
99.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    
100.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
     2 L" i' J+ L4 |7 b
101.        
     
102.         //ADC_DMACmd(ADC1,ENABLE);
     , a. T8 [" S8 c9 j  ~
103.        
     
104.         //ADC_Cmd(ADC1,ENABLE);
     
105.        
     
106.         //ADC_ResetCalibration(ADC1);
     2 N. ?- {1 j( V+ p- v
107.         //while(ADC_GetResetCalibrationStatus(ADC1));
     
108.        
     
109.         //ADC_StartCalibration(ADC1);
     
110.         //while(ADC_GetCalibrationStatus(ADC1));
     2 b6 Z2 k9 S+ G5 \; O' ^
111.        
     ) {9 o9 R" R9 V" ?# G2 ]
112.         //ADC_SoftwareStartConvCmd(ADC1,ENABLE);
     # T& M$ S  x3 l) X7 s  P8 x
113. }
     
114. void PrintHexU8(uint8_t data)
     : N) H1 f; C1 u& o5 J: b
115. {
     * X6 J/ B2 B0 e9 [& ?
116.         TxBuff[Count++] = data;
     
117.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     
118.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
     
119. }
     * A1 r  V6 \; Y; x3 z. x& N
120. 
     0 H  _- B3 G- y% q# n" w
121. void PrintString(uint8_t *s)
     + O% m+ ~# R8 f6 Y
122. {
     " t* B/ \( p4 G8 J( ]# [' E% h
123.         uint8_t *p;
     3 {0 L2 K" N$ F, y
124.         p=s;
     
125.         while(*p!= '\0')
     
126.         {
     
127.                 PrintHexU8(*p);
     
128.                 p++;
     
129.         }
     + j# G* |7 @8 C7 X2 {% P6 t( _! s
130. }
     " x+ i2 h/ x; ?/ j2 T" I
131. 
     
132. void PrintU16(uint16_t num)
     ' M+ r9 }. Y/ f; _! M
133. {
     % |/ V+ ^: t5 E0 }
134.         uint8_t w5,w4,w3,w2,w1;
     9 m( C; p8 c) }6 c! A
135.          w5 = num % 100000/10000;  
     
136.    w4 = num % 10000/1000;  
     % s  u) @* z/ [" U0 r1 g( |9 x
137.    w3 = num % 1000/100;  
     1 a+ J) R& ^, g3 ]3 v0 `! q' A  C
138.    w2 = num % 100/10;  
     
139.    w1 = num % 10;  
     * Y  u. N! r! n0 J
140.    PrintHexU8('0' + w5);  
     
141.    PrintHexU8('0' + w4);  
     # x; X; J7 P' X4 r# J! f
142.    PrintHexU8('0' + w3);  
     $ ], b4 V7 p: n7 x' F
143.    PrintHexU8('0' + w2);  
     
144.    PrintHexU8('0' + w1);
     
145. }
     ! {- P! F8 S: m$ `! G! }
146. 
       i+ ]8 _" _3 r5 ~7 x3 h
147. void Voltage_Printf(void)
     5 U% }& l3 {/ V/ ^9 v+ F: u
148. {
     " T- f: k2 R0 w3 H2 H! _
149.         Battery = (uint16_t)(2.0f *ADC_Value[0] / ADC_Value[1] *1.2f * 100);
     # z0 ^( D6 k' J  e- r
150.         PrintString("\r\nµ±Ç°µç³Øµçѹֵһ°Ù±¶£º");
     
151.         PrintU16(Battery);
     % ^1 y" F/ g  F( s2 c
152.         PrintString("V");
     
153. }
     
154. int main()
     ' D: n* w- J" y; A6 y
155. {
     1 [& R. L' a0 H9 j9 U* i9 T
156.         usart_init();
     ) z3 \/ s# D3 f* [- Z. F
157.         nvic_init();
     ) h8 ?5 f# Y& ~
158.         dma_init();
     ! F( Z9 k, U" j0 u- F, _
159.         adc_init();
     
160.         DMA_Cmd(DMA1_Channel1,ENABLE);
     " c7 u  i1 E- r, L: f8 ]8 J
161.         ADC_DMACmd(ADC1,ENABLE);
     / V/ z9 J2 R4 x
162.        
     0 }, B: X0 A- k. m# c) X$ O% P- q3 g& Q
163.         ADC_Cmd(ADC1,ENABLE);
     - G' N, T4 p8 H% t
164.        
     
165.         ADC_ResetCalibration(ADC1);
     3 x9 j8 Q) `( q1 \  D- p! U
166.         while(ADC_GetResetCalibrationStatus(ADC1));
     
167.        
     
168.         ADC_StartCalibration(ADC1);
     6 l8 A" ]: g& T$ x0 I7 M
169.         while(ADC_GetCalibrationStatus(ADC1));
     
170.        
     
171.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
     
172.         while(1)
     % d/ T" u- X4 W3 o9 S
173.         {
     
174.                 Voltage_Printf();
     
175.                 //PrintString("\r\nprint data!!\r\n");
     
176.                 delay(1000);
     
177.         }
     
178. }
     
179.        
     1 R& a' S5 F3 Y
180. void USART1_IRQHandler(void)
     
181. {
     
182.         if(USART1->SR & USART_SR_TC)
     
183.         {
     / m) z- {/ D2 B1 j* p8 }( J5 e
184.                 USART1->DR = TxBuff[TxCount++];
     1 \) f- G# G9 T" B( W7 K3 [
185.                 if(TxCount == Count)
     
186.                 {
     ! u; _) f, s3 v" F9 U( h) b
187.                         USART1->CR1 &= ~USART_CR1_TXEIE;
     
188.                 }
     
189.         }
     ' D$ X& J2 P: i
190.        
     
191.         if(USART1->SR & USART_SR_RXNE)
     
192.         {
     - n2 I: e+ }, q; ~1 A+ a
193.                 volatile int8_t com_data;
     
194.                 com_data = USART1->DR;
     
195.         }
     
196. }

复制代码

+ T2 Y) v  E2 b! z* Y————————————————
( t% ~& M4 P. x; n! D+ x& f7 J版权声明：家安