对于STM32的ADC模数转换器的介绍以及配置在文章《STM32单片机（六）. 传感器的使用》中已经详细介绍，在本章节中主要介绍DAC数模转换器以及DMA的使用。

1、DAC转换
) V* S$ p; v# P5 \& G4 g1.1 数模转换器的介绍
8 I" d8 X7 c" q, M2 y4 o- XDAC（Digital to analog converter），数字模拟转换器，可以将数字信号转换为模拟信号。DAC可以输出电压模拟信号，用来去驱动其它器件。STM32F1中的DAC模块是由12位电压输出数模转换器，可以配置为8位或12位模式，也可以与DMA控制器配合使用。在12位模式下，数据可使用左对齐或右对齐方式；8位模式下，数据只有右对齐方式。DAC含有两个输出通道，每个通道各对应一个转换器。在双通道模式下，每个通道可进行单独的转换；当两个通道组合在一起同步执行更新操作时，也可同时进行转换。DAC可通过输入参考电压引脚VREF+来提高转换后的数据精度，对于DAC通道的模块框图如下所示：
$ A; B( |) o. u  o( `: j

0 O& T0 \3 N6 x" }/ J1 g3 r* @
1.2 DAC的配置步骤
/ A$ l5 E/ a3 L+ C" q4 a) ^0 H" D使用库函数对DAC进行配置需要使用到库文件stm32f10x_dac.h和stm32f10x_dac.c，详细的步骤如下：
- d! ^) A0 ?. G( F
& M/ `2 Q2 V( N( u0 z, t0 G4 P1、 使能端口及DAC时钟，设置引脚为模拟输入模式；
& w) @) O9 T9 n' V# u在STM32F103中DAC两个通道对应的是PA4和PA5引脚，因此需要使能GPIOA以及DAC时钟，DAC是挂载在APB1总线上的设备，GPIOA是挂载在APB2总线上的设备。调用函数：RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟 RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);//使DA时钟

2、 初始化DAC，设置DAC工作模式；
调用函数：void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct);
9 }. X5 ]6 I3 `' N6 |/ t( \第一个参数选取DAC通道（DAC_Channelx），第二个参数结构体DAC_InitTypeDef的成员变量如下：
! O5 ?1 y% Q) r+ o! F3 w% Z
: R7 K, G  u. Y1 B  ?$ B

1. typedef struct
   
2. {
   
3. uint32_t DAC_Trigger;                                                         //DAC触发选择
   ) M' V8 X" ?. B" c/ ^% V5 z$ o
4. uint32_t DAC_WaveGeneration;                                        //DAC波形发生
   5 N1 [) q8 m' ]
5. uint32_t DAC_LFSRUnmask_TriangleAmplitude;        //屏蔽/幅值选择器
   ! `3 ?. I7 d. x" I
6. uint32_t DAC_OutputBuffer;                                                //DAC输出缓存
   
7. }DAC_InitTypeDef;

复制代码

3、 使能DAC输出通道；
) V* K% P6 O, Y5 s9 t调用函数：void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState);
. e$ @/ c8 g5 y4、 设置DAC输出值；
在使用12位数据右对齐的工作模式下，通过设置DHR12R1就可已在DAC输出引脚得到不同的电压值，调用函数：DAC_SetChannel1Data(DAC_Align_12b_R, 0);
读取DAC对应通道最后一次转换值调用函数：uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel);
& l" z, v* w( R4 h* C! Q
; R" o* k, p7 \6 A9 {, x1.3 应用示例
STM32使用按键控制DAC输出电压的大小，并将该数据通过串口输出，详细的代码模块如下：
$ `5 r! Z9 }" }( k2 g+ sdac.h
% p$ g+ g7 q  ~9 |3 d7 z6 Z

1. #ifndef _dac_H
   0 ?$ d- K& {: q0 L8 S  k: ]; `
2. #define _dac_H
   
3. 
   
4. #include "system.h"
   
5. void DAC1_Init(void);
   , d9 N# L4 ~. E0 v7 h( ?7 j
6. 
   
7. #endif

复制代码

0 Q& h! @; C& A; v0 [* v9 ~dac.c

1. #include "dac.h"
   
2. 
   
3. void DAC1_Init(void)
   
4. {
   
5. GPIO_InitTypeDef GPIO_InitStructure;
   $ c! p( Z3 E4 _) S
6. DAC_InitTypeDef DAC_InitStruct;
   
7. 
   
8. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
   
9. RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC,ENABLE);
   # l+ \2 l/ a) J0 e. b
10. 
    % l- E' L2 s' u  s; ~
11. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AIN;
    
12. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;
    7 P& g8 d. i, f4 e+ _
13. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
14. GPIO_Init(GPIOA,&GPIO_InitStructure);
    
15. 
    
16. DAC_InitStruct.DAC_Trigger=DAC_Trigger_None;         //不使用触发
    
17. DAC_InitStruct.DAC_WaveGeneration=DAC_WaveGeneration_None;        //不使用波形输出
    6 z0 m7 i- u/ X! i; L) |
18. DAC_InitStruct.DAC_LFSRUnmask_TriangleAmplitude=DAC_LFSRUnmask_Bit0;
    
19. DAC_InitStruct.DAC_OutputBuffer=DAC_OutputBuffer_Disable;        //关闭输出缓存
    
20. DAC_Init(DAC_Channel_1,&DAC_InitStruct);
    
21. 
    1 _4 J* g0 t) F: h. ~
22. DAC_Cmd(DAC_Channel_1, ENABLE);
    & U8 |) e0 u4 @; D
23. DAC_SetChannel1Data(DAC_Align_12b_R,0);                        //初始电压值设置为0
    3 \& @+ s/ B4 @+ S2 d. g* `# `9 N
24. }

复制代码

0 _$ O8 L6 @. A, p' z  wmain.c
6 t* ]" q2 Q; L1 F) I4 o0 }

1. #include "system.h"
   
2. #include "led.h"
   
3. #include "SysTick.h"
   + m- Y3 _/ H+ o
4. #include "usart.h"
   
5. #include "key.h"
   ) ^4 t+ b+ b& r: `  R* N
6. #include "dac.h"
     ?& a/ t& P7 F5 ?  F3 ]
7. 
   
8. int main()
   : o, N: T# C5 @$ a  x: d# K$ x; W
9. {
   : T4 o' L3 D3 U- _
10.         u8 i=0;
    ( _! b4 S2 C; Z" f1 w6 r/ E
11.         u8 key;
    
12.         u16 dacVal;
    
13.         u16 dac_value;
    # Z' k; g. y1 o; k4 m) J" r- j
14.         float U;
    # O: u2 W: @' q1 L) v
15.         SysTick_Init(72);
    
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
17.         LED_Init();
    / j5 v: w; C4 _2 @8 ]; F* t. r
18.         USART1_Init(9600);
    
19.         DAC1_Init();
    
20.   KEY_Init();
    4 d3 {1 P" T" N
21.         
    
22.         while(1)
    & s. C4 E8 y; F7 O
23.         {
    % A$ a; U7 f" j
24.                 key=KEY_Scan(0);
    + m) f( e3 W5 z" w( x
25.                 if(key==KEY_UP)
    
26.                 {
    , R: N) V1 a" e) N$ r
27.                         dacVal+=400;
    3 Q& S) h3 s/ X
28.                         if(dacVal>=4095)
    ( o" e6 W; w- S- ^& U3 w* m
29.                         {
    - \1 _9 S" d5 g$ H! n, t1 {! [: g
30.                                 dacVal=4095;
    
31.                         }
    . j3 K, O, {6 B5 z" {
32.                         DAC_SetChannel1Data(DAC_Align_12b_R,dacVal);                //更新电压
    1 C( z1 O# z" o8 n# T) J
33.                 }
    & H& Q1 H8 L) i5 M
34.                 else if(key==KEY_DOWN)
    
35.                 {
    
36.                         dacVal-=400;
    
37.                         if(dacVal<=0)
    7 P1 h: u1 Z/ R& L  m
38.                         {
    
39.                                 dacVal=0;
    / _: J0 |, l" f2 S3 D
40.                         }
    4 W* n: [% J. s
41.                         DAC_SetChannel1Data(DAC_Align_12b_R,dacVal);
    , G, d, S+ G: n
42.                 }
    1 g5 b6 J' H, v2 N3 m3 _) j
43.                 i++;
    3 Y2 c3 t2 Q* o" S+ O
44.                 if(i%20==0)
    
45.                 {
    
46.                         led1=!led1;
    
47.                 }
    ! Y  H3 {: U  `6 I, H$ e
48.                 if(i%50==0)
    ) |( E! a+ q6 E4 e& V6 A% R
49.                 {
    9 m6 c; r1 }( H; s8 n
50.                         dac_value=DAC_GetDataOutputValue(DAC_Channel_1);
    
51.                         U=(float)dac_value*(3.3/4096);
    
52.                         printf("输出电压为：%.2f\n",U);
    
53.                 }
    
54.                 delay_ms(10);
    7 y; O8 n5 ~5 Q0 a% ^
55.                
      E7 o1 Z/ z8 ^  `( l* O2 E
56.         }
    & T1 S7 G) }, T, q
57. }
    

复制代码

2、DMA数据传输
8 h9 ?* A  U$ E6 I2.1 DMA的介绍
DMA，Direct Memory Access，直接存储器访问。STM32中DMA可以实现外设与寄存器之间，存储器与存储器之间高效的数据传输，DMA传输数据的过程不需要CPU直接操作可以节省对CPU的占用。DMA是RAM和IO设备之间数据传输的通路，外设和存储器之间，存储器和存储器之间可以直接在通道上进行数据传输。在STM32F1中最多有2个DMA控制器（DMA2仅存在于大容量产品系列），DMA1有7个通道，DMA2有5个通道，每个通道可管理来自于一个或者多个外设对存储器访问的请求，面对这些请求通过一个仲裁器来协调其优先权。对于DMA的结构框图如下所示：
& L$ t% I3 X& l1 m( o, o

" o# b* |+ X" L4 [; FDMA和Cortex-M3内核共享系统数据总线，当CPU和DMA同时访问相同的目标时，DMA会请求暂停CPU访问系统总线若干个周期，总线仲裁器执行循环调度，以保证CPU至少可以得到一半的系统总线带宽。
DMA的处理过程： 当发生一个事件后，外设向DMA控制器发送一个请求信号，DMA控制器根据通道优先权处理请求。当DMA控制器开始访问发出请求的外设时，DMA控制器立即给其发送一个应答信号。外设从DMA得到应答信号后，外设立即释放请求，请求一旦被释放，DMA控制器同时撤销硬打信号。当有更多的请求时，外设可以启动下一个周期。
5 h. a8 T6 ]& \2 c) Q" N  ?DMA的数据配置： 外设到存储器，使用外设到存储器传输时，DMA外设寄存器的地址为外设的数据寄存器地址，DMA存储器的地址为用户自定义变量的地址；存储器到外设，使用存储器到外设的传输时，DMA外设寄存器地址对应的是其数据寄存器地址，DMA存储器地址为用户自定义变量（缓冲区，存储通过外设的数据）的地址；存储器到存储器，DMA外设寄存器地址为内部存储器（如Flash，可将其看作是外设）的地址，DMA存储器地址为用户自定义的变量（缓冲区，存储来自内部Flash的数据）的地址。DMA的传输完成分为两种模式，一次传输和循环传输。如果使用一次传输后DMA停止，若要在此传输，必须失能DMA后在重新配置方可继续传输；当使用循环传输时，一次传输完成后又再次恢复第一次传输时的配置进行数据传输，不断重复。

) C) t* E% E: W6 R& g2.2 DMA的配置步骤
对于DMA的配置，需要使用到库函数文件stm32f10x_dma.h和stm32f10x_dma.c，详细的步骤如下所示：
1、 使能DMA控制器时钟；
使能DMA时钟，需要通过AHB1ENR寄存器控制，调用函数：void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);
2、 初始化DMA通道；
9 q% U# i) A, |$ w" r% N需要配置DMA的通道、外设和内存地址、通道优先级以及传输数据量等，调用函数：void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct);
  D$ e* c. U. ~7 k其中第一个参数用于选择哪个DMA的通道x，第二个参数是一个结构体变量包含的成员变量如下：
/ b3 m0 e* {2 c% a3 @- m; \' s
7 b- E. _5 N) i6 g

1. typedef struct{
   
2.                 uint32_t DMA_PeripheralBaseAddr;                // 外设地址
   / }5 E; ?1 {) l% {0 F( d; S& B2 T
3.                 uint32_t DMA_MemoryBaseAddr;                 // 存储器地址
   
4.                 uint32_t DMA_DIR;                                         // 传输方向
   # b& U0 c$ j' k$ C. K& K: t
5.                 uint32_t DMA_BufferSize;                                // 传输数目
   
6.                 uint32_t DMA_PeripheralInc;                        // 外设地址增量模式
   " x% ~% K" d+ q1 z% Y8 \
7.                 uint32_t DMA_MemoryInc;                                 // 存储器地址增量模式
   
8.                 uint32_t DMA_PeripheralDataSize;                 // 外设数据宽度
   
9.                 uint32_t DMA_MemoryDataSize;                 // 存储器数据宽度
   
10.                 uint32_t DMA_Mode;                                         // 模式选择
    ( _6 N3 r7 e8 l; q
11.                 uint32_t DMA_Mode;                                         // 模式选择
    + ^- x& \: q5 W' ?! v: s
12.                 uint32_t DMA_M2M;                                         // 存储器到存储器模式
    
13. } DMA_InitTypeDef;

复制代码

3、 使能外设DMA功能；
配置好DMA后，需要使能外设的DMA功能，根据使用外设的不同调用相应的函数，如使能串口DMA的发送功能需要调用：USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
4、 开启DMA通道传输；
调用函数：void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Chammelx, FunctionalState NewState);
2 S7 K  X; o! u+ I5、 查询DMA传输状态。
8 X( J# L9 f/ w) F查询状态调用函数：FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG);
- l1 p) c# |  v3 D( n% A: p获取当前传输剩余数据量大小调用函数：uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx);
' w' k- l8 @5 W8 y( I# `  }设置传输数据量大小调用函数：void DMA_SeyCurrDatatCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber);

2 I" h% d1 c/ B$ W9 }2.3 应用示例
STM32使用按键控制DMA串口USART1的数据传送，详细的代码模块如下：
* L! w/ ^& t+ o- ^: ^4 e5 m
dma.h

1. #ifndef _dma_H
   
2. #define _dma_H
   
3. 
   
4. #include "system.h"
   
5. void DMAx_Init(u32 paddr,u32 maddr,u16 buffsize,DMA_Channel_TypeDef* DMAy_Channelx);
   ) _2 f3 h& t- S- P, ~# y( d6 T
6. void DMAx_Enable(DMA_Channel_TypeDef* DMAy_Channelx,u16 ndtr);
   
7. #endif

复制代码

1 Y* K, T: M8 cdma.c
" y$ _' e  l; r) S

1. #include "dma.h"
   / t6 M! J% B6 ]5 a- d6 B
2. 
   . ^: h0 w) Q; h, M( _# X
3. void DMAx_Init(u32 paddr,u32 maddr,u16 buffsize,DMA_Channel_TypeDef* DMAy_Channelx)
   
4. {
   
5.         
   
6.         DMA_InitTypeDef DMA_InitStruct;
   
7.         
   
8.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
   
9.         
   
10.         DMA_InitStruct.DMA_PeripheralBaseAddr=paddr;                                                //外设地址
    
11.         DMA_InitStruct.DMA_MemoryBaseAddr=maddr;                                                //内存地址
    0 c$ e# [8 ]& G: B9 L* q
12.         DMA_InitStruct.DMA_DIR=DMA_DIR_PeripheralDST;                                        //存储器到外设
    $ W! o! z9 Q4 D6 y' h" Y
13.         DMA_InitStruct.DMA_BufferSize=buffsize;                                                        //传输数据量大小
    
14.         DMA_InitStruct.DMA_PeripheralInc=DMA_PeripheralInc_Disable;                        //外设地址不增
    0 @) N  i9 ~. |
15.         DMA_InitStruct.DMA_MemoryInc=DMA_MemoryInc_Enable;                        //内存地址自增
    
16.         DMA_InitStruct.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;        //外设数据单位
    
17.         DMA_InitStruct.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte;                //内存数据单位
    , O. q" l/ Z" \; z# U
18.         DMA_InitStruct.DMA_Mode=DMA_Mode_Normal;                                                //一次传输
    
19.         DMA_InitStruct.DMA_Priority=DMA_Priority_Medium;                                        //通道优先级中
    ( K- G  P( a% Z$ S# f9 Y7 h: F
20.         DMA_InitStruct.DMA_M2M=DMA_M2M_Disable;                                                //存储器到存储器失能
    
21.         
    % ]2 `$ L0 F) F- }0 U
22.         DMA_Init(DMAy_Channelx,&DMA_InitStruct);
    " x6 _0 H- B# X; {0 Q
23.         
    
24. }
    9 b  {2 F& w, t& v
25. void DMAx_Enable(DMA_Channel_TypeDef* DMAy_Channelx,u16 ndtr)
    , @! X$ o' H; `
26. {
    9 g+ w2 i7 e* T
27.         DMA_Cmd(DMAy_Channelx, DISABLE);
    ( c' c* [0 X6 v( l" k: q9 I0 t& T0 `
28.         DMA_SetCurrDataCounter(DMAy_Channelx,ndtr);
    
29.         DMA_Cmd(DMAy_Channelx, ENABLE);
    5 P* d4 w7 q  r& t! @. {% n
30. }

复制代码

main.c
( o1 T4 A/ U2 n* f) X6 N
( G5 |5 o- n( E6 [* B3 c- X/ ]2 I) q

1. #include "system.h"
   : B! |7 e" Z$ N; c0 J
2. #include "led.h"
   : h8 l) f1 h  b* f2 F( r
3. #include "SysTick.h"
   
4. #include "usart.h"
   ) z! e0 z5 l6 d; N1 W5 r5 [, W( k
5. #include "key.h"
   4 R/ ?3 u9 C" M2 z1 t! b+ e, k6 {
6. #include "dma.h"
   
7. #define buf_len 5000
   
8. 
   
9. 
   ' t  B& R. X% s% H& b
10. u8 sendBuffer[buf_len];
    
11. 
    7 W$ N) W6 R/ B& I4 n2 R3 e
12. void send_Data(u8 *p)
    
13. {
    6 g2 o4 c( I, G& ~) j  b
14.         u16 i;
    
15.         for(i=0;i<buf_len;i++)
    
16.         {
    
17.                 *p='5';
    
18.                 p++;
    8 P# b2 ~; Y7 O0 v/ A' r
19.         }
    
20. }
    . B* L$ K" h( E' k) N, q/ d; m
21. 
    
22. int main()
    
23. {
    
24.         u8 i=0;
    & k5 X0 V& y% z( P( {6 A% r
25.         u8 key;
    / t1 n8 G' H8 w* ^3 z: _
26.         
    / {) f' U; e. w6 {
27.         SysTick_Init(72);
    4 h' O6 d' X" b1 u' Q
28.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    % |: J: G4 N( |8 ~
29.         LED_Init();
    
30.         USART1_Init(9600);
    ! F9 M6 H+ V7 x' W5 u
31.   KEY_Init();
    
32.         DMAx_Init((u32)&USART1->DR,(u32)sendBuffer,buf_len,DMA1_Channel4);
    . ?8 Y- m/ w9 ^* q% L* J
33.         send_Data(sendBuffer);
    
34.         
    3 M$ i1 A& y: S. V
35.         while(1)
    
36.         {
    
37.                 key=KEY_Scan(0);
    
38.                 if(key==KEY_UP)
    
39.                 {
    / ^3 J! B% q) o9 K
40.                         USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);        //开启外设DMA功能
    
41.                         DMAx_Enable(DMA1_Channel4,buf_len);
    7 s4 e  [) [3 `# E3 C
42.                         
    
43.                         while(1)
    $ c2 M/ h: u- ~! L
44.                         {
    
45.                                 if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=0)        //判断DMA数据是否发送完成
    , O3 k7 q4 @  V! s" b( ^0 t
46.                                 {
    7 w* G; D" w; d8 i% Y# q
47.                                         DMA_ClearFlag(DMA1_FLAG_TC4);
    ! |9 Y+ i" d. T) j2 e
48.                                         break;
    ( L, j& A5 z" C) V
49.                                 }
    8 M) e% l6 j9 S. V
50.                                 led2=!led2;
    # b- y2 w2 S$ q7 o: W+ v
51.                                 delay_ms(300);
    
52.                         }
    
53.                 }
    
54.                 i++;
    0 u5 @/ Z% d0 _
55.                 if(i%20==0)
    + B+ Y5 c, C0 _; ]# H: e& R" ~
56.                 {
    # x# x% i3 [/ _' V/ o- v
57.                         led1=!led1;
    
58.                 }
    
59.                 delay_ms(10);
    
60.         }
    
61. }

复制代码

- M6 C. t" p* _4 u8 r8 H
& L- Y- I. q2 n& g
- C" B$ j' G9 ^' e+ U! Q+ w9 ]9 b
5 M' l# @5 q$ K: T6 l3 e


% m: i( ~' X% O/ N

1 v9 |# G$ n. v2 \3 _% K9 k
0 B; x0 Y) B0 _* Z2 G! X1 z. \