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

1、DAC转换
1.1 数模转换器的介绍
DAC（Digital to analog converter），数字模拟转换器，可以将数字信号转换为模拟信号。DAC可以输出电压模拟信号，用来去驱动其它器件。STM32F1中的DAC模块是由12位电压输出数模转换器，可以配置为8位或12位模式，也可以与DMA控制器配合使用。在12位模式下，数据可使用左对齐或右对齐方式；8位模式下，数据只有右对齐方式。DAC含有两个输出通道，每个通道各对应一个转换器。在双通道模式下，每个通道可进行单独的转换；当两个通道组合在一起同步执行更新操作时，也可同时进行转换。DAC可通过输入参考电压引脚VREF+来提高转换后的数据精度，对于DAC通道的模块框图如下所示：
! A* `( z5 d2 g


! M% y5 i9 y1 ~2 E( d3 x  A1.2 DAC的配置步骤
使用库函数对DAC进行配置需要使用到库文件stm32f10x_dac.h和stm32f10x_dac.c，详细的步骤如下：

1、 使能端口及DAC时钟，设置引脚为模拟输入模式；
在STM32F103中DAC两个通道对应的是PA4和PA5引脚，因此需要使能GPIOA以及DAC时钟，DAC是挂载在APB1总线上的设备，GPIOA是挂载在APB2总线上的设备。调用函数：RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);//使能GPIOA时钟 RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE);//使DA时钟
; H4 x8 C# d' ?; N# Z
) l+ Q) D' \% ^9 E2、 初始化DAC，设置DAC工作模式；
调用函数：void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct);
第一个参数选取DAC通道（DAC_Channelx），第二个参数结构体DAC_InitTypeDef的成员变量如下：

1. typedef struct
   3 s- z* J+ B% Q. Z
2. {
   ) C: }; o1 L+ W0 u( A4 G
3. uint32_t DAC_Trigger;                                                         //DAC触发选择
     X' I  B! Z( W+ I3 M6 N; D  m. {
4. uint32_t DAC_WaveGeneration;                                        //DAC波形发生
   
5. uint32_t DAC_LFSRUnmask_TriangleAmplitude;        //屏蔽/幅值选择器
   
6. uint32_t DAC_OutputBuffer;                                                //DAC输出缓存
   
7. }DAC_InitTypeDef;

复制代码

  I7 |: R" @2 F* ^" {9 F3、 使能DAC输出通道；
. {% y  W* J. i1 m调用函数：void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState);
4、 设置DAC输出值；
在使用12位数据右对齐的工作模式下，通过设置DHR12R1就可已在DAC输出引脚得到不同的电压值，调用函数：DAC_SetChannel1Data(DAC_Align_12b_R, 0);
+ S7 Q' N# y5 y  A( D/ e读取DAC对应通道最后一次转换值调用函数：uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel);

1.3 应用示例
STM32使用按键控制DAC输出电压的大小，并将该数据通过串口输出，详细的代码模块如下：
: p9 }/ e3 u& X' F( idac.h
; o/ W9 a" R5 }5 n6 U

1. #ifndef _dac_H
   + x4 p" l: A4 X* M4 y8 H
2. #define _dac_H
   & W; y5 w6 r5 H0 N
3. 
   ' X: ^/ I) R0 [8 t" V/ B- F
4. #include "system.h"
   & q# R. A8 \. ~7 k& B4 K' k
5. void DAC1_Init(void);
   $ q& C* K2 v* O
6. 
   
7. #endif

复制代码

dac.c

1. #include "dac.h"
   & [4 q7 K  g4 B% _# W$ P
2. 
   ! l6 G6 F9 t7 G0 |: B$ ?+ |; U! H0 [
3. void DAC1_Init(void)
   
4. {
   
5. GPIO_InitTypeDef GPIO_InitStructure;
   
6. DAC_InitTypeDef DAC_InitStruct;
   + D- k+ T5 X! \8 c
7. 
   
8. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
   
9. RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC,ENABLE);
   * J, j1 \, G& S9 x5 r: {5 E  b! q, R+ }" g
10. 
    / _; K* E0 l% r; o- Q" Y
11. GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AIN;
    ; M# V7 U$ E, f! e9 q! ~
12. GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;
    
13. GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
14. GPIO_Init(GPIOA,&GPIO_InitStructure);
    
15. 
    8 y+ J( i- Z! U) U" y# @
16. DAC_InitStruct.DAC_Trigger=DAC_Trigger_None;         //不使用触发
    
17. DAC_InitStruct.DAC_WaveGeneration=DAC_WaveGeneration_None;        //不使用波形输出
    " B( f, x# g& r
18. DAC_InitStruct.DAC_LFSRUnmask_TriangleAmplitude=DAC_LFSRUnmask_Bit0;
    : o- q6 G" ]1 g& K7 [, A
19. DAC_InitStruct.DAC_OutputBuffer=DAC_OutputBuffer_Disable;        //关闭输出缓存
    / r, t8 `* g; Z$ T( D; l
20. DAC_Init(DAC_Channel_1,&DAC_InitStruct);
    0 M. b  g8 R" s9 l; ^
21. 
    2 r/ T4 [6 X, Z% B2 ]+ ]% l
22. DAC_Cmd(DAC_Channel_1, ENABLE);
    
23. DAC_SetChannel1Data(DAC_Align_12b_R,0);                        //初始电压值设置为0
    ( b- s5 }4 i1 H8 w
24. }

复制代码

- I/ d; s% e7 [# emain.c

1. #include "system.h"
   
2. #include "led.h"
   
3. #include "SysTick.h"
   $ R- u. c5 ]! Z+ f) x: ^: F
4. #include "usart.h"
   6 p. {% g) V) L1 [2 C, u. E  u
5. #include "key.h"
   % e, {1 z; d! C/ H3 V; {
6. #include "dac.h"
   4 u% w3 |! v* B2 P3 y; ~9 V
7. 
   9 g0 l& `6 e3 ]& [
8. int main()
   
9. {
   
10.         u8 i=0;
    
11.         u8 key;
    , }" i& d! i6 J6 A
12.         u16 dacVal;
    
13.         u16 dac_value;
    
14.         float U;
    
15.         SysTick_Init(72);
    
16.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
17.         LED_Init();
    
18.         USART1_Init(9600);
    4 G5 j8 O5 y+ B  v* X+ S
19.         DAC1_Init();
    + F. l  o6 m7 Q2 E% K. w+ v
20.   KEY_Init();
    . ^4 k) L  c; Z: z& a8 E
21.         
    
22.         while(1)
    ( V& G2 T. M, u- N1 V6 {2 F
23.         {
    ; D& ]9 o; N# M. ]4 o
24.                 key=KEY_Scan(0);
    $ |7 g2 {* t: ?3 E, O% J
25.                 if(key==KEY_UP)
    
26.                 {
    
27.                         dacVal+=400;
    9 `+ H( q, f9 m% n# O: j
28.                         if(dacVal>=4095)
    # @& I7 `4 R4 h* f/ j/ F; ~8 S
29.                         {
    
30.                                 dacVal=4095;
    
31.                         }
    
32.                         DAC_SetChannel1Data(DAC_Align_12b_R,dacVal);                //更新电压
    # s% j! X( ~  i  Y# O
33.                 }
    
34.                 else if(key==KEY_DOWN)
    5 `0 Q7 k( P0 E8 O
35.                 {
    
36.                         dacVal-=400;
    * E) W2 z; d# y" |/ D, a
37.                         if(dacVal<=0)
    
38.                         {
    1 I8 V" {: [8 l) K
39.                                 dacVal=0;
    
40.                         }
    
41.                         DAC_SetChannel1Data(DAC_Align_12b_R,dacVal);
    + u: @3 \/ z- @% q  X
42.                 }
    % k! y( r: g1 U
43.                 i++;
    
44.                 if(i%20==0)
    3 k+ n1 d( X7 U* A+ l  @( N
45.                 {
    - B. l& q' U/ _5 J
46.                         led1=!led1;
    5 G# ]- I5 e7 A( P+ n
47.                 }
    3 R3 Y6 m) c8 n: K2 i& G7 O
48.                 if(i%50==0)
    3 P1 q* q) [) g) Q( {. G4 j
49.                 {
    % L; X4 {3 K- G
50.                         dac_value=DAC_GetDataOutputValue(DAC_Channel_1);
    
51.                         U=(float)dac_value*(3.3/4096);
    
52.                         printf("输出电压为：%.2f\n",U);
    
53.                 }
    ; k* E5 N+ @+ ~
54.                 delay_ms(10);
    
55.                
    
56.         }
      g5 t4 w) x* _9 w1 Z
57. }
    

复制代码

2、DMA数据传输
3 U# Z9 e( r% i4 S, O7 [2.1 DMA的介绍
: [+ R, `+ r5 mDMA，Direct Memory Access，直接存储器访问。STM32中DMA可以实现外设与寄存器之间，存储器与存储器之间高效的数据传输，DMA传输数据的过程不需要CPU直接操作可以节省对CPU的占用。DMA是RAM和IO设备之间数据传输的通路，外设和存储器之间，存储器和存储器之间可以直接在通道上进行数据传输。在STM32F1中最多有2个DMA控制器（DMA2仅存在于大容量产品系列），DMA1有7个通道，DMA2有5个通道，每个通道可管理来自于一个或者多个外设对存储器访问的请求，面对这些请求通过一个仲裁器来协调其优先权。对于DMA的结构框图如下所示：
  R, F$ r% ]" b$ t

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

$ o, N- K, a* Y2.2 DMA的配置步骤
对于DMA的配置，需要使用到库函数文件stm32f10x_dma.h和stm32f10x_dma.c，详细的步骤如下所示：
$ u0 w+ p( J2 N1、 使能DMA控制器时钟；
使能DMA时钟，需要通过AHB1ENR寄存器控制，调用函数：void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState);
2、 初始化DMA通道；
- Y) k/ u- c8 S8 H需要配置DMA的通道、外设和内存地址、通道优先级以及传输数据量等，调用函数：void DMA_Init(DMA_Channel_TypeDef* DMAy_Channelx, DMA_InitTypeDef* DMA_InitStruct);
其中第一个参数用于选择哪个DMA的通道x，第二个参数是一个结构体变量包含的成员变量如下：
  B1 D  E" @  x1 k  u: ^  ~

1. typedef struct{
   & {, F6 q+ I  V% ~4 C$ u& Y  j
2.                 uint32_t DMA_PeripheralBaseAddr;                // 外设地址
   
3.                 uint32_t DMA_MemoryBaseAddr;                 // 存储器地址
   , R7 y+ E0 n7 d/ \- k2 q" G* L3 H
4.                 uint32_t DMA_DIR;                                         // 传输方向
   4 c( ~  N0 H  s2 a( _
5.                 uint32_t DMA_BufferSize;                                // 传输数目
   ) y9 I' Z9 x' y6 U" \
6.                 uint32_t DMA_PeripheralInc;                        // 外设地址增量模式
   8 z0 M  `7 @, q/ a
7.                 uint32_t DMA_MemoryInc;                                 // 存储器地址增量模式
   / f+ h  H  Q; R$ g/ A
8.                 uint32_t DMA_PeripheralDataSize;                 // 外设数据宽度
   # y5 @* v- P) ]6 n) q4 Z. M
9.                 uint32_t DMA_MemoryDataSize;                 // 存储器数据宽度
   % U  N& V* Q( s3 [
10.                 uint32_t DMA_Mode;                                         // 模式选择
    
11.                 uint32_t DMA_Mode;                                         // 模式选择
    
12.                 uint32_t DMA_M2M;                                         // 存储器到存储器模式
    
13. } DMA_InitTypeDef;

复制代码

' L0 G0 U" \: J9 |& e  X3、 使能外设DMA功能；
  C. ~6 W" ^3 r% z% y' D配置好DMA后，需要使能外设的DMA功能，根据使用外设的不同调用相应的函数，如使能串口DMA的发送功能需要调用：USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
4、 开启DMA通道传输；
调用函数：void DMA_Cmd(DMA_Channel_TypeDef* DMAy_Chammelx, FunctionalState NewState);
( b) n# m& o' V- r% \8 H5、 查询DMA传输状态。
( f: `' J# t6 }  @; g2 k查询状态调用函数：FlagStatus DMA_GetFlagStatus(uint32_t DMAy_FLAG);
获取当前传输剩余数据量大小调用函数：uint16_t DMA_GetCurrDataCounter(DMA_Channel_TypeDef* DMAy_Channelx);
: S6 A  W( N8 {& q  U! K设置传输数据量大小调用函数：void DMA_SeyCurrDatatCounter(DMA_Channel_TypeDef* DMAy_Channelx, uint16_t DataNumber);

% s) L- }; A1 U* v8 A2.3 应用示例
STM32使用按键控制DMA串口USART1的数据传送，详细的代码模块如下：

dma.h

1. #ifndef _dma_H
   
2. #define _dma_H
   & `) D3 X* b9 R/ H
3. 
   ' P7 X- X) }! k5 C6 A
4. #include "system.h"
   ) s+ y' ?. g8 _; `$ }9 a, T
5. void DMAx_Init(u32 paddr,u32 maddr,u16 buffsize,DMA_Channel_TypeDef* DMAy_Channelx);
   
6. void DMAx_Enable(DMA_Channel_TypeDef* DMAy_Channelx,u16 ndtr);
     Z  y' ]& E" x( M3 U
7. #endif

复制代码

% E) S0 [. p$ M) B  v& E$ D6 _dma.c
# ]5 J) h9 }- N

1. #include "dma.h"
   
2. 
   
3. void DMAx_Init(u32 paddr,u32 maddr,u16 buffsize,DMA_Channel_TypeDef* DMAy_Channelx)
   7 z3 \3 ?6 `" s/ |/ ?6 K
4. {
   % ]' G5 H$ A% T/ O
5.         
   : g$ _2 c4 c: I  I
6.         DMA_InitTypeDef DMA_InitStruct;
   ( [& j8 ]3 J+ @. I) y
7.         
   
8.         RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
   % s5 U' w* ?7 a' P* J6 j1 c
9.         
   2 z0 u# S4 m( F" x
10.         DMA_InitStruct.DMA_PeripheralBaseAddr=paddr;                                                //外设地址
    
11.         DMA_InitStruct.DMA_MemoryBaseAddr=maddr;                                                //内存地址
    
12.         DMA_InitStruct.DMA_DIR=DMA_DIR_PeripheralDST;                                        //存储器到外设
    6 d/ c! r* P& P3 O( M" x& p  w
13.         DMA_InitStruct.DMA_BufferSize=buffsize;                                                        //传输数据量大小
    
14.         DMA_InitStruct.DMA_PeripheralInc=DMA_PeripheralInc_Disable;                        //外设地址不增
    . @4 }, n. @% @
15.         DMA_InitStruct.DMA_MemoryInc=DMA_MemoryInc_Enable;                        //内存地址自增
    
16.         DMA_InitStruct.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte;        //外设数据单位
    
17.         DMA_InitStruct.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte;                //内存数据单位
    ; X/ I- C! @+ s. ~; V
18.         DMA_InitStruct.DMA_Mode=DMA_Mode_Normal;                                                //一次传输
    
19.         DMA_InitStruct.DMA_Priority=DMA_Priority_Medium;                                        //通道优先级中
    ) m* z9 ~7 W+ o2 j4 E
20.         DMA_InitStruct.DMA_M2M=DMA_M2M_Disable;                                                //存储器到存储器失能
    - l: _/ V; \( m' ^; I. w5 L
21.         
    * e& x2 s+ Q/ R/ G
22.         DMA_Init(DMAy_Channelx,&DMA_InitStruct);
    6 o+ m  I( ?1 P+ Q% I* D
23.         
    6 L3 b# e: I; O& W8 S" I
24. }
    
25. void DMAx_Enable(DMA_Channel_TypeDef* DMAy_Channelx,u16 ndtr)
    6 n: M! p, K" I1 |: }
26. {
    
27.         DMA_Cmd(DMAy_Channelx, DISABLE);
    - x" T7 r, k. R7 r0 r
28.         DMA_SetCurrDataCounter(DMAy_Channelx,ndtr);
    
29.         DMA_Cmd(DMAy_Channelx, ENABLE);
    7 i! e. M6 U+ o, {* H3 G
30. }

复制代码

) x0 G0 a7 T  Z' K. r+ Pmain.c

1. #include "system.h"
   
2. #include "led.h"
   
3. #include "SysTick.h"
   
4. #include "usart.h"
   , e  ~6 @* Z: }* E. v
5. #include "key.h"
   " @2 z( A" G  j2 v) y' g3 h+ c
6. #include "dma.h"
   
7. #define buf_len 5000
   
8. 
   & R7 X; s  e9 T' g
9. 
   
10. u8 sendBuffer[buf_len];
    
11. 
      p, ~; y2 ~( s' z4 U% D
12. void send_Data(u8 *p)
    * N" c. w% `/ D$ h
13. {
    
14.         u16 i;
      I4 \. [% n% R5 Z
15.         for(i=0;i<buf_len;i++)
    
16.         {
    ) u- A( O. p) O' @
17.                 *p='5';
    
18.                 p++;
    
19.         }
    ) B2 ]% p  k% r  X4 \
20. }
    5 ?% Y" g3 G: x
21. 
    
22. int main()
    : j8 U  }# a3 f! z3 g* a1 z: S
23. {
    
24.         u8 i=0;
    
25.         u8 key;
    / U/ ]4 J1 e9 ~* K" t& Q
26.         
    
27.         SysTick_Init(72);
    
28.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    ; M/ q, U- ]% I7 u+ D
29.         LED_Init();
    
30.         USART1_Init(9600);
    
31.   KEY_Init();
    
32.         DMAx_Init((u32)&USART1->DR,(u32)sendBuffer,buf_len,DMA1_Channel4);
    # u# H3 y( X0 n% q: V* g" \
33.         send_Data(sendBuffer);
    
34.         
    * Y; n' L* @6 s  H9 V, u( X& l
35.         while(1)
    
36.         {
    7 N1 d( g/ a% Y: S! {1 [) w$ x
37.                 key=KEY_Scan(0);
    
38.                 if(key==KEY_UP)
    
39.                 {
    + ?/ J8 M' C1 q" s$ N* m" x
40.                         USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);        //开启外设DMA功能
    
41.                         DMAx_Enable(DMA1_Channel4,buf_len);
    
42.                         
    - X" J; X) `) ^: [
43.                         while(1)
    ; i# z! i" u) q& K- [1 T) b" N
44.                         {
    & |( I5 x) e- R
45.                                 if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=0)        //判断DMA数据是否发送完成
    . F3 ]0 B8 w5 [1 v5 J
46.                                 {
    & h; w% Z& t4 t9 V9 x3 f- y7 Z
47.                                         DMA_ClearFlag(DMA1_FLAG_TC4);
    $ B! B, e5 K  c: T6 _6 a- K
48.                                         break;
    7 j2 R7 ], Q% A1 M& X8 \% P5 P
49.                                 }
    . o) e7 I3 ?0 Y" M4 `
50.                                 led2=!led2;
    & |6 s2 P  p7 g7 H: W
51.                                 delay_ms(300);
    ! {- F4 |3 [/ y
52.                         }
    
53.                 }
    
54.                 i++;
    $ L/ C, Y) @: F9 m$ \8 U
55.                 if(i%20==0)
    
56.                 {
    
57.                         led1=!led1;
    4 i% m$ f+ R5 W" E/ k: d
58.                 }
    : R5 i; }- Q7 _
59.                 delay_ms(10);
    
60.         }
    4 o; V1 Z8 k/ \+ v7 Y7 t6 }3 J+ c
61. }

复制代码

% I% I6 `  M# a5 I  w2 Z
& p1 _- [. {9 E
" ^# [6 r' [6 R- E' M3 l+ Q* N) R