本文简单介绍了STM32F103C8，通过DMA方式读取ADC并通过串口中断向电脑端打印出当前电源ADC的值。
$ e5 u3 e6 s1 o1 g+ r6 u
现在先将设计过程的主要步骤介绍如下：
3 [1 o0 B  l. h( j) a. l5 w4 I                1，串口配置
1 ]8 O5 R0 Y9 j' A4 G* N                2，中断配置
) @, X! \; f( F# [+ T9 n                3，DMA配置
7 u% M& _! s& N# z2 R% O                4，ADC配置
                5，中断服务函数
                6，主函数

5 P6 Y; A7 ~. Q0 }- @+ N: p       先总结下博主在这次基础设计中犯的错误，在中断初始化函数中，没有将中断通道使能，导致电脑端没有接收到数据，发现后就去检查串口初始化函数了，结果没有发现错误，而是检查了一遍代码才发现错误。发现串口无法工作后，先核查初始化函数，如果问题没有解决，第二步，如果是串口中断方式，接下来检查，中断初始化函数，如果是串口查询方式，接下来检查主函数的串口查询代码。
" }* D3 |) ]# I; P0 M! S7 c) m
& N7 R$ M4 `$ \$ T; u7 k, r接下来详细介绍各个步骤：

% B$ |( U4 J: @, m1，串口配置
8 _# J5 t5 X' O5 G8 `

1. void usart_init(void)
   
2. {
   
3.         GPIO_InitTypeDef GPIO_usart;定义GPIO结构体
   
4.         USART_InitTypeDef USART_usart;定义串口结构体
   2 e8 @  q/ j- i% b+ I6 n# V8 O
5.        
   
6.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1 ,ENABLE);使能外设时钟
   ! u- R+ R- B+ ]: P$ J
7.        
   
8.         GPIO_usart.GPIO_Pin = GPIO_Pin_9;
   
9.         GPIO_usart.GPIO_Mode = GPIO_Mode_AF_PP;
   / z4 _" {" Y  h: s
10.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    
11.         GPIO_Init(GPIOA,&GPIO_usart);配置发送口
    
12.        
    ; Z" q5 \# L# ?. s8 J3 N/ o8 y
13.         GPIO_usart.GPIO_Pin = GPIO_Pin_10;
    2 i. y% r# @  h: K
14.         GPIO_usart.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
15.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    
16.         GPIO_Init(GPIOA,&GPIO_usart);配置接受口
    : Y& J+ `% K% D# Z: ^+ e4 u- ^
17.        
    ' |6 B# z7 s- t9 S3 [0 u0 J
18.         USART_usart.USART_BaudRate = 115200;设置传输波特率
    + Q! q" l; o, C6 I
19.         USART_usart.USART_WordLength = USART_WordLength_8b;设置串口发送字长
    
20.         USART_usart.USART_StopBits = USART_StopBits_1;设置停止位
    
21.         USART_usart.USART_Parity = USART_Parity_No;不进行奇偶校验
    4 X: M  p" {" P. j+ f% B9 _
22.         USART_usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;硬件流使能
    
23.         USART_usart.USART_Mode = USART_Mode_Tx;设置为发送模式
    
24.         USART_Init(USART1,&USART_usart);初始化串口寄存器
    
25.        
    7 d8 U6 J9 p5 \3 e' z6 O
26.         USART_Cmd(USART1,ENABLE);串口使能
    
27.         USART_ClearFlag(USART1,USART_FLAG_TC);清除已发送位，防止第一位发不出去
    
28. }

复制代码

) t% x! t  v) l4 z2，中断配置

1. void nvic_init(void)
   
2. {
   " [3 ]5 b5 \& w
3.         NVIC_InitTypeDef nvic_usart;定义中断结构体
   4 F( }) ?! {/ m/ @
4.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);设置中断分组
   
5.         nvic_usart.NVIC_IRQChannel = USART1_IRQn;制定中断服务函数通道
   
6.         nvic_usart.NVIC_IRQChannelPreemptionPriority = 1;抢占优先级1
   ! C6 u. v! U% E" _0 |* [
7.         nvic_usart.NVIC_IRQChannelSubPriority = 0;子优先级0
   5 @; v; a3 N+ ~; q4 y. ?' b* g1 N
8.         nvic_usart.NVIC_IRQChannelCmd = ENABLE;通道使能
   4 c9 R! @2 F" B! ]. ?
9.         NVIC_Init(&nvic_usart);中断寄存器初始化
   
10. }

复制代码

+ e& R- R2 M1 D1 [3 c9 e9 l( m' N/ Q
3，DMA配置

1. void dma_init(void)
   
2. {
   
3.         DMA_InitTypeDef dma;定义DMA结构体
   9 K( s- i: B& y$ ^0 c! W
4.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);打开时钟
   
5.        
   
6.         DMA_DeInit(DMA1_Channel1);现将DMA，通道1寄存器复位
   
7.         dma.DMA_PeripheralBaseAddr = (u32)&ADC1->DR;设置外设地址
   8 E& M; Q4 k# m) ]4 @& ]
8.         dma.DMA_MemoryBaseAddr = (uint32_t)ADC_Value;设置存储器地址
   
9.         dma.DMA_DIR = DMA_DIR_PeripheralSRC;设置传输方向为 外设到存储器
   
10.         dma.DMA_BufferSize = 2;数据缓冲为设置为2
    0 x8 Z: q7 q, u
11.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable;外设地址固定
    
12.         dma.DMA_MemoryInc = DMA_MemoryInc_Enable;寄存器地址自增
    8 `# u4 [5 \! T
13.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;外设数据位宽度半字
    1 E$ P) V) x: \$ S
14.         dma.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;存储器数据位宽度半字
    ) R! m+ C; j! A, M
15.         dma.DMA_Mode = DMA_Mode_Circular;DMA工作在循环模式
    
16.         dma.DMA_Priority = DMA_Priority_High;DMA通道为高优先级
    
17.         dma.DMA_M2M = DMA_M2M_Disable;内存到内存传输使能
    
18.         DMA_Init(DMA1_Channel1,&dma);初始化DMA寄存器
    
19.        
    . ~" r8 Z( U4 O8 }1 T% J
20.         //DMA_Cmd(DMA1_Channel1,ENABLE);使能通道1 （笔者把这句放到主函数中了，在这里写也行，只不过是笔者认为放到主函数中便于理解）
    4 i0 R: K: I9 u+ s2 u9 u
21. }

复制代码

4，adc配置
0 Y! q5 d6 r. W5 A) t- X; F

1. void adc_init(void)
   " l5 e: O4 h8 [6 J0 F& P
2. {
   " F5 t1 T4 I5 t1 h! h
3.         ADC_InitTypeDef adc;定义adc结构体
   ! G. P6 I' {$ T5 o3 j
4.         GPIO_InitTypeDef adc_gpio;定义GPIO结构体
   , [+ H- p$ b" v% f1 j9 R
5.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);使能外设
   % {; d# |$ J; j- w0 C6 L& l
6.        
   - i6 i" X0 m6 w+ f
7.         adc_gpio.GPIO_Pin = GPIO_Pin_1;
   
8.         adc_gpio.GPIO_Mode = GPIO_Mode_AIN;
   
9.         GPIO_Init(GPIOB,&adc_gpio);使能ADC的测试通道
   
10.        
    
11.         ADC_DeInit(ADC1);复位ADC1寄存器
    7 e$ X1 x! M/ R& S. E1 u$ D- H! I
12.         ADC_TempSensorVrefintCmd(ENABLE);使能内部参照电压
    
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;不使用外部触发工作模式
    
17.         adc.ADC_DataAlign = ADC_DataAlign_Right;数据设置为右对齐
    
18.         adc.ADC_NbrOfChannel = 2;两个转换通道
    ( Y3 v: K8 R8 ^) _/ [7 ]9 G
19.        
    : J8 y6 n8 f, `! g1 v7 u4 _
20.         ADC_Init(ADC1,&adc);初始化寄存器
    
21.        
    
22.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);对通道9采样（电源电压）
    / f7 @4 `% r" o2 V
23.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);对通道11采样（参考电压）
    ; G2 @" u- o9 K0 ~, [( Q
24.        
    
25.         //ADC_DMACmd(ADC1,ENABLE);ADC 的DMA通道使能
    
26.        
    
27.         //ADC_Cmd(ADC1,ENABLE);ADC使能
    , `9 I. s# Y/ E. m9 W: K4 d
28.        
    6 u/ @- ?8 `4 r3 |
29.         //ADC_ResetCalibration(ADC1);复位ADC1的校准寄存器
    $ ^9 W/ h4 x+ l7 g1 w
30.         //while(ADC_GetResetCalibrationStatus(ADC1));等待复位完成
    
31.        
    # p9 ^0 }' L7 V
32.         //ADC_StartCalibration(ADC1);开始ADC1校准
    
33.         //while(ADC_GetCalibrationStatus(ADC1));等待校准完成
    
34.        
    1 n1 C* V( `5 T: ~: v3 N$ u$ }
35.         //ADC_SoftwareStartConvCmd(ADC1,ENABLE);ADC1的软件转换使能（注：这些注释的部分我放到主函数里了，放在这里也行，只不过，我感觉我那样便于理解）
    
36. }

复制代码

- p2 Z1 f7 P/ ~
5，中断服务函数

1. void USART1_IRQHandler(void)
   $ m0 b: ^9 {; o% o
2. {
   2 j% f6 M1 S/ |8 Y) \: \, _5 O
3.         if(USART1->SR & USART_SR_TC)判断是否能发送数据
   
4.         {
   
5.                 USART1->DR = TxBuff[TxCount++];笔者将转换到的电压值存到TxBuff[0]中了
   
6.                 if(TxCount == Count)等到传完一次数据，就退出中断
   7 k1 x1 [3 H% J/ i# L" l) Z
7.                 {
   * n9 F: H, Z8 n! R  ^
8.                         USART1->CR1 &= ~USART_CR1_TXEIE;
   
9.                 }
   & c( W3 s' S1 D0 n. c
10.         }
    3 w# W0 {+ w) Q( T- E/ D
11. }

复制代码

' j: g3 R: v& P& R, c" Q
3 C8 s4 r8 A* w. y, C9 ~6，主函数
. W& @7 ?3 E# I! Y6 i& ?6 k# o

1. int main()
   
2. {
   $ j: _2 U& z9 `- @$ s. w
3.         usart_init();串口初始化
   
4.         nvic_init();中断初始化
   
5.         dma_init();DMA初始化
   / z; G) }, |- }" ~+ w9 S: \
6.         adc_init();ADC初始化
   , [0 H& E+ p2 O; J
7.         DMA_Cmd(DMA1_Channel1,ENABLE);//见上文
   
8.         ADC_DMACmd(ADC1,ENABLE);同上
   # U2 [0 x1 C) C7 h) ]+ {7 ]
9.        
   / Y% R9 h: C5 m" D8 ?; D5 u
10.         ADC_Cmd(ADC1,ENABLE);同上
    9 S5 j& q) K" w) I/ M
11.        
    ! n3 F1 g8 w8 l" J
12.         ADC_ResetCalibration(ADC1);同上
    
13.         while(ADC_GetResetCalibrationStatus(ADC1));同上
    
14.        
    
15.         ADC_StartCalibration(ADC1);同上
    . `9 q3 h' t8 ]+ f2 w# E
16.         while(ADC_GetCalibrationStatus(ADC1));同上
    9 Q& [0 m! G* x" s" U
17.        
    $ M& w. t0 M+ L: r( d' Z8 u
18.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);同上
    
19.         while(1)循环打印电压值
    
20.         {
    
21.                 Voltage_Printf();用于打印电压
    $ ?9 \8 ?! w; i+ ^, \
22.                 //PrintString("\r\nprint data!!\r\n");
    - O1 u) O* Y: {$ O$ p
23.                 delay(1000);延时
    
24.         }

复制代码

1. void Voltage_Printf(void)
   & i. i9 D& c- r1 u% A2 M  z) }- R
2. {
   * G- ]. M6 n4 Q! c- Q* V
3.         Battery = (uint16_t)(2.0f *ADC_Value[0] / ADC_Value[1] *1.2f * 100);根据参考电压按比例计算电源电压
   
4.         PrintString("\r\n当前电压值的一百倍：");
   / }% W" l! S! \1 Z2 K
5.         PrintU16(Battery);
   1 `$ u8 r& u0 p6 j) i
6.         PrintString("V");
   
7. }

复制代码

下面粘贴完整代码
  s  E8 x  {* X% D9 a) U0 w1 a1 ]

1. #include<stm32f10x.h>
   7 p  d$ L& q6 ]
2. 
   ( `3 i7 g% S5 {7 R+ B6 ]
3. uint16_t ADC_Value[2];
   
4. static uint16_t Battery=0;
     H8 g* J8 A' z0 V9 t
5. uint8_t TxCount = 0;
   5 v; g' |4 ?8 X8 B
6. uint8_t Count = 0;
   
7. static uint8_t TxBuff[250];
   ( D* ~+ ?- N7 `( j+ x( u& Z' z
8. volatile uint8_t RxBuffer[50];
   
9. 
   4 e3 j, Z6 Z3 @% D9 E. ^
10. void delay(uint32_t n)
    
11. {
    
12.         int i,j;
    
13.         for(i=0;i<n;i++)
    
14.                 for(j=0;j<8500;j++);
    
15. }
    
16. 
    ( R$ ?9 |/ h' ?2 [0 n) y
17. void usart_init(void)
    7 C8 k6 h7 q  x8 j' ]3 y
18. {
    / h4 B/ N  ~  s' }! A
19.         GPIO_InitTypeDef GPIO_usart;
    
20.         USART_InitTypeDef USART_usart;
    
21.        
    7 V1 o- S5 A+ O! j
22.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_USART1 ,ENABLE);
    6 I! I& P0 r9 e3 D& O
23.        
    ! k3 L$ N" y: ^, s8 V# W. K
24.         GPIO_usart.GPIO_Pin = GPIO_Pin_9;
    
25.         GPIO_usart.GPIO_Mode = GPIO_Mode_AF_PP;
    & }$ G6 y0 T6 N. k( s# x% y
26.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    
27.         GPIO_Init(GPIOA,&GPIO_usart);
    
28.        
    
29.         GPIO_usart.GPIO_Pin = GPIO_Pin_10;
    0 m5 T4 ]3 O" o5 W8 R$ t* ]; q
30.         GPIO_usart.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    4 T* x3 T; }) K9 M( e- l, H
31.         GPIO_usart.GPIO_Speed = GPIO_Speed_50MHz;
    * @& d4 ]9 A% r) k2 F, n* K+ f
32.         GPIO_Init(GPIOA,&GPIO_usart);
    
33.        
    
34.         USART_usart.USART_BaudRate = 115200;
    7 [4 c9 E: s- n  X1 \9 S8 ?) v6 e
35.         USART_usart.USART_WordLength = USART_WordLength_8b;
    : S. A7 }; f1 k/ ?; ]' I
36.         USART_usart.USART_StopBits = USART_StopBits_1;
    , a) R3 g4 X, C" g0 T
37.         USART_usart.USART_Parity = USART_Parity_No;
    & h6 f% y' s' E: B
38.         USART_usart.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    / M: B0 a( {/ j: v9 W
39.         USART_usart.USART_Mode = USART_Mode_Tx;
    
40.         USART_Init(USART1,&USART_usart);
    1 Y- Z& e4 o- ]  _
41.        
    % \/ ]  x, O- k4 Y, d% J9 X% X3 K5 b
42.         USART_Cmd(USART1,ENABLE);
    7 V" r3 B* T0 g
43.         USART_ClearFlag(USART1,USART_FLAG_TC);
    
44. }
    
45.        
    
46. void nvic_init(void)
    8 G7 h9 l; H/ x1 V) F( o
47. {
    
48.         NVIC_InitTypeDef nvic_usart;
    
49.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    . W# R# f' H" R' F7 Y% N3 f( P
50.         nvic_usart.NVIC_IRQChannel = USART1_IRQn;
    
51.         nvic_usart.NVIC_IRQChannelPreemptionPriority = 1;
    
52.         nvic_usart.NVIC_IRQChannelSubPriority = 0;
    
53.         nvic_usart.NVIC_IRQChannelCmd = ENABLE;
      L0 V6 g' x+ }$ R0 J1 J  t& O
54.         NVIC_Init(&nvic_usart);
    $ b' |( j8 W. c2 ~' p
55. }
    
56.        
    4 {- J, z: b$ V4 A
57. void dma_init(void)
    
58. {
    
59.         DMA_InitTypeDef dma;
    
60.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    
61.        
    + _3 \7 c, v8 F
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 v0 U" c, N1 J& b5 s" I. [& b
67.         dma.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    
68.         dma.DMA_MemoryInc = DMA_MemoryInc_Enable;
    
69.         dma.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
    0 L& {, O' W3 K9 o8 ~
70.         dma.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
    + L* i0 L2 \" w6 p" l6 v
71.         dma.DMA_Mode = DMA_Mode_Circular;
    
72.         dma.DMA_Priority = DMA_Priority_High;
    
73.         dma.DMA_M2M = DMA_M2M_Disable;
    
74.         DMA_Init(DMA1_Channel1,&dma);
    
75.        
    
76.         //DMA_Cmd(DMA1_Channel1,ENABLE);
    
77. }
    
78. void adc_init(void)
    
79. {
    , x  w5 i7 b% d' L( p
80.         ADC_InitTypeDef adc;
    
81.         GPIO_InitTypeDef adc_gpio;
    ( C( D# h3 v6 O; _. n+ F
82.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1 | RCC_APB2Periph_GPIOB,ENABLE);
    
83.        
    7 w; Q$ y3 [" W( g% f' M" p/ G: d' [
84.         adc_gpio.GPIO_Pin = GPIO_Pin_1;
    
85.         adc_gpio.GPIO_Mode = GPIO_Mode_AIN;
    $ V- h% R+ ^1 A' t. L
86.         GPIO_Init(GPIOB,&adc_gpio);
    
87.        
    # l: r, h2 K1 A7 U
88.         ADC_DeInit(ADC1);
    
89.         ADC_TempSensorVrefintCmd(ENABLE);
    ! \) E: m! ?/ M9 h
90.         adc.ADC_Mode = ADC_Mode_Independent;
    
91.         adc.ADC_ScanConvMode = ENABLE;
    
92.         adc.ADC_ContinuousConvMode = ENABLE;
    9 A* x2 H8 A- A- S
93.         adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    
94.         adc.ADC_DataAlign = ADC_DataAlign_Right;
    
95.         adc.ADC_NbrOfChannel = 2;
    ' Z: T& i5 s6 T& v
96.        
    6 r, N. F( v6 y2 U& ~
97.         ADC_Init(ADC1,&adc);
    ( H* l5 G9 }) c7 B+ {4 T" U, L9 S) o
98.        
    
99.         ADC_RegularChannelConfig(ADC1,ADC_Channel_9,1,ADC_SampleTime_239Cycles5);
    0 Z( q) p. P+ z7 x/ X0 {
100.         ADC_RegularChannelConfig(ADC1,ADC_Channel_17,2,ADC_SampleTime_239Cycles5);
     ; l9 d/ _; v: c: P
101.        
     
102.         //ADC_DMACmd(ADC1,ENABLE);
     , B0 i7 f" R! F- `1 Y7 l% e7 `$ W
103.        
     
104.         //ADC_Cmd(ADC1,ENABLE);
     
105.        
     ! f- e5 [' j3 c2 D9 r9 C$ F+ }, M
106.         //ADC_ResetCalibration(ADC1);
     3 r8 c( t/ f" ]
107.         //while(ADC_GetResetCalibrationStatus(ADC1));
     " F* I- c, Y! K) R9 j; `
108.        
     
109.         //ADC_StartCalibration(ADC1);
     : P! z* ]- w) K3 B
110.         //while(ADC_GetCalibrationStatus(ADC1));
     
111.        
     7 ^/ s5 N% z( l& U1 H: M
112.         //ADC_SoftwareStartConvCmd(ADC1,ENABLE);
     + @: X3 d/ W/ D( `
113. }
     
114. void PrintHexU8(uint8_t data)
     $ ]0 [: [! }( [8 f
115. {
     
116.         TxBuff[Count++] = data;
     
117.         if(!(USART1->CR1 & USART_CR1_TXEIE))
     6 l+ w* G8 I( z  J
118.                 USART_ITConfig(USART1,USART_IT_TXE,ENABLE);
     1 \; {# H8 q( L, e8 v0 `6 ?
119. }
       K6 ~9 G9 i7 v9 c
120. 
     % }9 c% P9 P) ]( f
121. void PrintString(uint8_t *s)
     
122. {
     
123.         uint8_t *p;
     
124.         p=s;
     
125.         while(*p!= '\0')
     
126.         {
     / z) w) I% I( h  H
127.                 PrintHexU8(*p);
     
128.                 p++;
     ! O7 t/ H8 i7 G7 S- H! d( ~
129.         }
     5 b$ {3 n9 z6 D' H; g+ v
130. }
     9 c! G# ^0 D/ P/ H/ H
131. 
     
132. void PrintU16(uint16_t num)
     
133. {
       @6 N' Q" X% P
134.         uint8_t w5,w4,w3,w2,w1;
     
135.          w5 = num % 100000/10000;  
     % ]; o. h1 ~* G( z, V* y
136.    w4 = num % 10000/1000;  
     
137.    w3 = num % 1000/100;  
     
138.    w2 = num % 100/10;  
     & P; s/ D' c) t6 q* d# |% ?" R6 W
139.    w1 = num % 10;  
     8 Q  e1 u7 g5 J' H4 |
140.    PrintHexU8('0' + w5);  
     
141.    PrintHexU8('0' + w4);  
     
142.    PrintHexU8('0' + w3);  
     
143.    PrintHexU8('0' + w2);  
     
144.    PrintHexU8('0' + w1);
     
145. }
     
146. 
     
147. void Voltage_Printf(void)
     
148. {
     ! T% f5 ?; `3 ]8 L7 ^
149.         Battery = (uint16_t)(2.0f *ADC_Value[0] / ADC_Value[1] *1.2f * 100);
     9 I: z. k( t' w& G( b
150.         PrintString("\r\nµ±Ç°µç³Øµçѹֵһ°Ù±¶£º");
     7 U8 z5 p7 ^1 v7 H& w, @3 K1 Z* W
151.         PrintU16(Battery);
     / o( y. c( [/ j6 B* B, Z4 w
152.         PrintString("V");
     
153. }
     
154. int main()
     4 `4 q3 p: A# O9 ?# i& P" J
155. {
     $ }" S' t- Q7 z) P6 C% X! b) n/ Q* v/ f
156.         usart_init();
     3 }) g1 K: j- H# ]0 o
157.         nvic_init();
     
158.         dma_init();
     - J& q# P4 W+ D) y  G% y8 _/ }
159.         adc_init();
     2 S6 ?3 l* \& N$ ~: z8 J, a
160.         DMA_Cmd(DMA1_Channel1,ENABLE);
     . P/ A0 }/ A0 J+ I4 d
161.         ADC_DMACmd(ADC1,ENABLE);
     
162.        
     
163.         ADC_Cmd(ADC1,ENABLE);
     * H+ P9 c0 R' q0 P: Y) ^
164.        
     
165.         ADC_ResetCalibration(ADC1);
     ' \6 L. z* \( e& h: U
166.         while(ADC_GetResetCalibrationStatus(ADC1));
     
167.        
     
168.         ADC_StartCalibration(ADC1);
     . t! p& w% [, [& D
169.         while(ADC_GetCalibrationStatus(ADC1));
     3 Q4 n2 A7 H* q2 {; @
170.        
     * [% W9 c" n4 {) Q0 W6 P
171.         ADC_SoftwareStartConvCmd(ADC1,ENABLE);
     
172.         while(1)
     
173.         {
     
174.                 Voltage_Printf();
     " l' d3 j& p0 H; k  n. z
175.                 //PrintString("\r\nprint data!!\r\n");
     
176.                 delay(1000);
     $ h7 A9 L5 n8 g$ A- k, Z6 u) E
177.         }
     0 G. N2 ~( o0 _, m( Y- J7 g4 q
178. }
     # \& \% J; q* v& g* T
179.        
     ( b3 Z$ \- O. z7 W
180. void USART1_IRQHandler(void)
     
181. {
     
182.         if(USART1->SR & USART_SR_TC)
     
183.         {
     ' J- A: _: K# F; ]# Y
184.                 USART1->DR = TxBuff[TxCount++];
     
185.                 if(TxCount == Count)
     
186.                 {
     
187.                         USART1->CR1 &= ~USART_CR1_TXEIE;
     
188.                 }
     8 F2 ]( A* _; f8 S- \$ E
189.         }
     & C: \) i) g+ O; w# ]
190.        
     
191.         if(USART1->SR & USART_SR_RXNE)
     + u$ ~# Y8 K; U3 [6 r$ O
192.         {
     3 l# G, d, i, C1 D4 O9 v
193.                 volatile int8_t com_data;
     7 U; C7 _( W% O  f
194.                 com_data = USART1->DR;
     
195.         }
     4 O5 `8 J5 l5 V8 l0 b" ?0 F
196. }

复制代码

————————————————
* q% ?+ W/ n# N. \- K版权声明：家安


+ Z$ V( M* n1 t3 Y+ E! y