STM32笔记（四）DMA、USART的演示

[复制链接]

私奔发布时间：2009-1-4 14:30

技术帖
文章封面:	-
文章简介:	-

   这里有个小小的例子，来演示DMA模块与系统程序并行工作。
　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
　　这个是相应的代码例子，基于STM32F103VBT6

/******************************************************************************
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
* 串口依然发送，表明DMA传输是一个独立的过程。
* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理
* 作者：jjldc（九九）
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6
*******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x_lib.h"
#include "stdio.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
#define USART1_DR_Base  0x40013804

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
#define SENDBUFF_SIZE 10240
vu8 SendBuff[SENDBUFF_SIZE];
vu8 RecvBuff[10];
vu8 recv_ptr;

/* Private function prototypes -----------------------------------------------*/
void RCC_Configuration(void);
void GPIO_Configuration(void);
void NVIC_Configuration(void);
void DMA_Configuration(void);
void USART1_Configuration(void);

int fputc(int ch, FILE *f);
void Delay(void);

/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name  : main
* Description : Main program.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
int main(void)
{
u16 i;
#ifdef DEBUG
debug();
#endif
recv_ptr = 0;

RCC_Configuration();
GPIO_Configuration();
NVIC_Configuration();
DMA_Configuration();
USART1_Configuration();

printf("\r\nSystem Start...\r\n");
printf("Initialling SendBuff... \r\n");
for(i=0;i {
      SendBuff = i&0xff;
1 L2 y7 |5 N$ E) {  a# Y8 y }
9 W: r: N* H' g$ G printf("Initial success!\r\nWaiting for transmission...\r\n");- L2 C/ g' K7 b. n
//发送去数据已经准备好，按下按键即开始传输
* a# y$ U$ R% C# J8 n* H' G" O while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
/ t! x) c) [  y+ [- p5 M7 x & v+ }7 C4 F: |* S8 P1 z; j: J
printf("Start DMA transmission!\r\n");+ x6 H& B' w1 x# c! `: [% {

1 L1 ~& L: t" y8 @; ~0 Q //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
" \, ^4 c4 W$ }+ v( D4 v USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
# T# s5 J  P. a //开始一次DMA传输！
' s) @9 R0 n6 k" b! T8 B DMA_Cmd(DMA1_Channel4, ENABLE);2 v5 b6 A) [4 Y7 o* r; ^: P
- R/ M5 ]- o; N% c% _2 V- [
//等待DMA传输完成，此时我们来做另外一些事，点灯6 t" T* \8 @# [( v
//实际应用中，传输数据期间，可以执行另外的任务) ?( e- ?5 B, Y
while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
. e. r  H* a8 C4 `) X9 ?4 f2 Z {* I6 e% j7 U. z# l- }% u! x) S
      LED_1_REV;    //LED翻转9 d' e6 {. _+ K6 J, a: G" u+ b9 C2 H/ P7 @
      Delay();       //浪费时间
& T4 R+ I" T/ G2 F }$ O1 R+ h2 C, M$ A  r/ `
//DMA传输结束后，自动关闭了DMA通道，而无需手动关闭' S# Q" |, m# c# d6 {- V# Z$ |& h
//下面的语句被注释3 P* t' J* F+ ?: s2 C3 z
//DMA_Cmd(DMA1_Channel4, DISABLE);
( L; Y2 Z: _. A5 o) N
  k2 U. l) ?6 X( I' m/ Z8 }( w) m printf("\r\nDMA transmission successful!\r\n");4 Z: r7 n1 Y: Z: ^
9 N3 C/ O' k# h2 P

* h% l$ D$ o/ a$ j /* Infinite loop */3 a! J1 a: a! a4 q
while (1)
% n8 T; z' _) X0 y& n8 ] {
' v6 E/ I" L& `' L }# M, @) O) d! e0 m' L7 ?2 p6 w" V' U
}0 ^8 |& K+ w7 p8 [: L. s4 e) X0 x( _

0 q1 X% n& q7 X2 P) f$ C% c+ I1 b/*******************************************************************************/ e  s- i; }" l3 W
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)
, c- e# g' _1 d/ A8 K( N* D* Description : 串口发一个字节
( c% c% P) G. O1 i8 q* Input       : int ch, FILE *f2 x1 Q8 O; L3 ]8 L8 i
* Output       : # K( c! p6 z2 ^6 M( \
* Return       : int ch% M/ D; U+ o% h0 ]8 _
* 这个是使用printf的关键
" e) ]; x8 i: k' ^*******************************************************************************/
9 l3 J5 u3 F4 o! j: \6 O8 oint fputc(int ch, FILE *f), N. y, i: O. w$ y3 Q8 ~
{9 T3 X/ B, X0 p7 u5 N) y
//USART_SendData(USART1, (u8) ch);
5 X7 c& _  q7 L USART1->DR = (u8) ch;
3 ^) s; N3 V$ p5 m* o ( b; l' L, t' m( [, L
/* Loop until the end of transmission */
" D& ^$ q2 L& v0 M. F$ H while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
- n  b% W) l4 w; Y8 T) k {
8 c/ ^  `* Z4 D+ m1 A7 ] }
8 Q2 G, l8 f6 ?0 T0 Q7 b% o8 O! P' O6 @
return ch;0 p6 X  w# ?- L9 q( U- K  \
}
; R5 \1 f/ c4 \; t5 i9 B$ E4 V; z
/*******************************************************************************8 [" N  ^+ m( |) v0 \4 z
* Function Name  : Delay
5 R- y' v4 i6 j6 R- Y* Description : 延时函数
! v8 Y1 x9 I! X/ @* Input       : None: T8 X8 u% C  f' e) j
* Output       : None' T2 [- f2 d2 L0 `" J6 `
* Return       : None/ C, U3 V% |" [
*******************************************************************************/
# ~: O/ E/ ~; `+ \- G4 A1 pvoid Delay(void)
* Z5 M  ]6 F. k# w9 R$ n{# n8 ^3 ]. Z1 D0 _# H
u32 i;
( Q0 x7 A$ C. Y, {1 T for(i=0;i外设! s4 U* p. o4 Q
//每次传输位：8bit2 A' C  J8 g. Y' k8 u9 |
//传输大小DMA_BufferSize=SENDBUFF_SIZE( _! `* Y; b; D; |3 W* @" J
//地址自增模式：外设地址不增，内存地址自增1
; G8 R, ~. }4 P' I9 n8 W0 @6 O //DMA模式：一次传输，非循环( [8 S7 G& I, G( J
//优先级：中" x+ ~7 }: B" @! e
DMA_DeInit(DMA1_Channel4);- D9 M& ?: v! u, C
DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
* t) |+ {# a" f DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;8 d, J5 j6 z) w: Z$ s, E
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
. H  i9 o5 q/ b+ U7 U* ^ DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;  d9 d: R6 R# J0 Q
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
$ n# @* I& [2 ?) a. s; q$ ^: \6 O DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;3 y% l5 k$ b9 ]1 N+ t
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
1 u/ `" v' h0 O4 {: n8 w DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;/ g. ^* m) _  n3 |0 a3 @
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;( r- }+ Y# e! R
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
: ]4 t3 S; A8 B' v  l% \! k DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;; L; z/ q  i1 h4 D0 x$ Z
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
2 D) T0 \1 Y: {/ d6 I; D8 A}

赞收藏评论44 发布时间：2009-1-4 14:30

44个回答

jjldc 回答时间：2009-1-4 15:59:06

RE:STM32笔记（四）DMA、USART的演示

大哥，转发我的东西，也把附件带上啊，请给我的博客一个地址吧，注明一下出处，嘿嘿。辛苦您啦！

赞评论

私奔回答时间：2009-1-5 12:18:28

回复:STM32笔记（四）DMA、USART的演示

原帖由私奔于2009-01-04 14:30发表:0 @& y1 \' X5 _: @2 E
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。2 @! C( C# L9 U! b1 U- t" P% Z
　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
" k, X2 |9 u4 c/ u) k　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
. x5 _7 j: }" B1 s　　这个是相应的代码例子，基于STM32F103VBT6# U' ?% V! v3 `' ^4 y' i- |

9 ?6 C# I* R% y2 g9 e, V2 v" g) j! d2 O# H
/******************************************************************************3 F. j# e7 _7 l) e, o% V9 p  k
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()' {* f# ^. w7 m. b' T8 Z1 y
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输
( ]7 C" I8 |, u1 o- z! S: b* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，5 D" v# w; \# i; l/ W8 Z+ U$ N
* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART
2 I/ R6 f5 b# }! h9 E1 w* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可
9 f% A- Q/ ]4 q* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
4 [- S' c0 c, B6 X+ P8 t$ L* 串口依然发送，表明DMA传输是一个独立的过程。
+ v% d! t6 S0 S5 @; |1 i$ A* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理+ v$ \" v$ k+ R& v, T* f! M( P
* 作者：jjldc（九九）9 u: _4 e2 r1 M/ z
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6' ^% G; k* ^. K1 h" L2 P+ k
*******************************************************************************/7 Q9 A' c# ^/ I9 p
+ m* o  n* c+ W3 ]
/* Includes ------------------------------------------------------------------*/" T  U; l+ Q1 p3 `
#include "stm32f10x_lib.h"
#include "stdio.h"0 g' [8 ^" `8 t6 f/ r

: A0 K& S$ b4 x: z. v/* Private typedef -----------------------------------------------------------*/
# Q  f5 H" b. |& {/* Private define ------------------------------------------------------------*/
4 e1 e1 {% B$ T/ F" b% t#define USART1_DR_Base 0x40013804' y9 n+ q( a7 s$ `. Z- H3 U: A

! B4 k2 c) V9 V3 B1 H/* Private macro -------------------------------------------------------------*/5 r+ o6 D6 e& P7 F
/* Private variables ---------------------------------------------------------*/+ b! B+ C0 C# T& Q/ r  w
#define SENDBUFF_SIZE   10240
7 z1 @- d6 o7 G' rvu8 SendBuff[SENDBUFF_SIZE];
2 I* M: J) ?1 f( _vu8 RecvBuff[10];
* t9 o9 x/ W) M7 rvu8 recv_ptr;; r( Y- P8 e. g

; {, k0 N) P! g) b9 \/* Private function prototypes -----------------------------------------------*/
, `" T7 d1 k, t4 {3 pvoid RCC_Configuration(void);7 v: @. I0 w; M+ U. j+ S; R" y
void GPIO_Configuration(void);
+ e. \9 a+ z9 V) k: [void NVIC_Configuration(void);
* J8 I9 Y! U: c& jvoid DMA_Configuration(void);
+ ]% D5 p5 m1 a! lvoid USART1_Configuration(void);
# H8 w; G1 h. h, u; \' ]# G2 n" E# M
- S/ _: f# |( P( f& J0 P% T0 Gint fputc(int ch, FILE *f);
, N, t6 n' e6 |5 f' f: u$ d% z2 Y! G7 wvoid Delay(void);
1 H5 e1 h3 e! J. p) F4 M! T3 E
4 ]) z3 P# L8 d+ P, ^0 p/* Private functions ---------------------------------------------------------*/
' Z, r' W2 V( K- J1 ~- \$ v7 s- d  H/*******************************************************************************
" h2 U. m% D  u; ?% W& ^* Function Name : main
2 Q( N" Z' ^- l* Description    : Main program.
- L4 h& ^/ N7 G* Input          : None& d; U2 z1 m1 e8 o. ]: j
* Output         : None
; p: h+ r; |% z: M. l* Return         : None
" r. y9 e0 Z5 v2 W4 o% Q. e*******************************************************************************/
" s3 ]+ o) R1 f7 b$ a" W7 m, Jint main(void)8 g' t9 U9 ?, L! v( C# p1 q4 e
{
$ H+ @0 o5 B& a* \  f* C( N% r    u16 i;
3 }- c5 q2 C: c  n9 |#ifdef DEBUG* g& w0 S( `8 y8 I. {4 q
    debug();
  b3 t7 A* n7 k#endif
: Y* @7 P7 }  E    recv_ptr = 0;& z/ i$ f7 B% s) F, x0 C
    ) A) o6 @) A+ Z" r5 i2 q$ N+ a
    RCC_Configuration();) h0 H( J/ H* s/ i; j
    GPIO_Configuration();: b2 X2 p; N+ F4 x# J
    NVIC_Configuration();" w, ~+ g/ ?% |0 |
    DMA_Configuration();
# D1 [1 i( R) R4 f    USART1_Configuration();5 i0 R0 A4 X. W7 E! P
    / X+ l. l0 M! p( u- c
    printf("\r\nSystem Start...\r\n");
5 a/ r. X" V/ W    printf("Initialling SendBuff... \r\n");
* _2 O4 A1 |* |* a  ]$ Z    for(i=0;i    {
6 |/ R- a; g( G' |8 j% A( z        SendBuff = i&0xff;; b! S1 D3 g% K/ x6 M6 n
    }$ T* o1 W- q( \7 J5 |% x; ^
    printf("Initial success!\r\nWaiting for transmission...\r\n");, v) R* v- n6 j# `" a) j4 D
    //发送去数据已经准备好，按下按键即开始传输
$ j4 L( Z+ {8 s! _) `% ?9 V    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
* J1 f+ X. d. }& x: b5 X    ) o; l. G! K: r4 I" s  {9 f
    printf("Start DMA transmission!\r\n");- X5 c+ o4 b/ ^& H
    7 n3 ]% X6 S* E6 O. Z
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作6 B6 o* a. H/ o" d+ \8 H
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);  A3 S4 ]3 {* I, d8 g
    //开始一次DMA传输！
: @7 M6 H; l" z+ i5 S+ r    DMA_Cmd(DMA1_Channel4, ENABLE);
& j9 d! X6 D4 T7 o4 ]- V  H4 u- I    0 c* A( v; u) }# {
    //等待DMA传输完成，此时我们来做另外一些事，点灯
0 Z" T8 j& T* `! i0 G  c    //实际应用中，传输数据期间，可以执行另外的任务* s/ Y) g. F, R  T7 ?0 D
    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
: P% I# F" ?% y+ y3 Y    {0 D5 }: T4 z0 K5 n" c& @
        LED_1_REV;      //LED翻转
& g4 W4 R( b% U' g/ f5 G) J! {; l* V        Delay();        //浪费时间
7 |! q( G2 `. k+ a    }8 u- h: v' g: s" H3 W& B4 S2 [
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭4 u  Q2 B% X% e* Z% o
    //下面的语句被注释
7 F! `9 F( }8 W1 P+ \- ?- ~- T    //DMA_Cmd(DMA1_Channel4, DISABLE);# L* x% L1 s; s

% h6 j8 ~4 I' E# x" P' |    printf("\r\nDMA transmission successful!\r\n");
& J; G6 N# B; u% x1 O( E/ S  D/ o+ e% {9 y1 D
    $ E# o2 S5 R, _- s. a5 f
    /* Infinite loop *// F( m/ N% O& ~5 V: C+ `
    while (1)+ N+ T+ _0 l$ t7 u0 Y) Y
    {
0 ]0 l5 n/ S; I( m4 y; N    }
" v- x3 M' ?0 |& m4 L9 i+ g1 N' R}
" [& ?3 D0 H# U; v* U' @: i( j) V
/*******************************************************************************
: G4 U7 H4 p( l6 J* ?0 C) J* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f): p# r, t5 n0 v
* Description    : 串口发一个字节
/ G& g- f4 U3 A) y# v9 n: X% {* Input          : int ch, FILE *f$ t+ [2 V% e5 o8 |- b
* Output         :
/ b, {0 W# k. S* Return         : int ch  L) K: L6 S$ A$ K, Q
* 这个是使用printf的关键
6 X. m" |- x& v9 T2 B*******************************************************************************/& K* m: W9 [* h; ?* A
int fputc(int ch, FILE *f)
- i  `& F  I$ e$ q! S$ f9 P9 Y{
: {2 I6 m  ?  s0 r    //USART_SendData(USART1, (u8) ch);5 c) t7 X: g1 h# Q4 F& s3 m% o
    USART1->DR = (u8) ch;& n; _% g" a" n( h* |2 D
    # Z) s0 T* Z; l$ Y7 z
    /* Loop until the end of transmission */
  b/ _% f$ G/ t( H. c: `6 j    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
9 [3 n9 E0 ~5 N& N% i. u2 X. _    {
. A  d: `. R6 Q+ ~- e, h5 K    }8 u& o8 Z- U* J* e$ n( M7 J
* k5 g  l% J( N. U* F, F9 P
    return ch;
3 k; Z% y' y% U5 p, ~}" T/ v3 i+ d4 Q. v( E
9 l) h% s' }0 A" Z' z" K
/*******************************************************************************
+ r! i) y& C% B  }* V; q: }* Function Name : Delay
( I7 ~, L/ `5 T; z0 t8 m* Description    : 延时函数
' L. U2 n: ?$ ~* Input          : None' J5 v5 L* s- f, r
* Output         : None
# x8 I- m  O: {% A( s" Q+ [+ u0 {* Return         : None( c2 H/ y3 ~5 T6 _* P; p
*******************************************************************************/3 {% J0 |4 i, Y- N9 `
void Delay(void): ~1 ~% G/ ]$ K
{
' F" j% w6 H! C' w% M& {0 o    u32 i;
7 `/ t' }& ~0 o7 Q% V, p4 l4 F    for(i=0;i外设! F0 R3 ^( m* C+ ]# r
    //每次传输位：8bit$ A: o- l  N: p4 T
    //传输大小DMA_BufferSize=SENDBUFF_SIZE
. t9 }9 a" w4 P+ n    //地址自增模式：外设地址不增，内存地址自增1- A7 L& P/ ?% T
    //DMA模式：一次传输，非循环
- B% a4 U' r- ~* _9 ^    //优先级：中
. R5 B* Y4 a% Q. \" m# i7 [    DMA_DeInit(DMA1_Channel4);
7 W, V9 ^; ^4 m! h$ K    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
5 u( ~- W! T2 I7 K  ~+ m    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
2 }0 ~6 L/ P& N. U    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;. W9 I: B' l( }5 K1 o1 }
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
  M, G0 K8 @9 c/ z1 m    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
1 D/ d+ D+ C5 n) R; g) b    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;9 p2 n+ l. R1 e7 o" z5 f1 c. a
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;0 U- z8 l9 J% [' D( U
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;4 @0 F2 H3 C$ h2 Z
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
; f$ M2 O" p9 I    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;" P; c$ n; X6 f& Y1 {. ^
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
/ y/ d* E4 x) R    DMA_Init(DMA1_Channel4, &DMA_InitStructure);$ O0 _1 f2 Q; T+ ?  g' `( e
}