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;
" y8 t4 k5 }  z# ?0 O) V }
) M: p1 Y# x2 t' d, Q' A printf("Initial success!\r\nWaiting for transmission...\r\n");
3 h# m: O' X! P. V1 l2 s! H  z //发送去数据已经准备好，按下按键即开始传输! _7 _9 j9 v2 V, W9 N$ T
while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));  I" d- i# k. x6 o
" d3 D6 S8 ?& w  s
printf("Start DMA transmission!\r\n");6 b" N# g( j. d( H

: F1 o8 N+ n% t //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作; g8 n! ^; L8 V
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
; R( Y6 C+ `4 I/ z+ ]" T& T //开始一次DMA传输！
) j3 c% T; }9 Z DMA_Cmd(DMA1_Channel4, ENABLE);. i% h7 l% I9 o
6 \% c+ u  L+ _
//等待DMA传输完成，此时我们来做另外一些事，点灯; j/ d6 ^# o" C+ E" \
//实际应用中，传输数据期间，可以执行另外的任务
6 Q% e" p5 L' K2 @# g while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
' C. H) s9 q8 k* v) x {
0 s, U! |- w! B! U0 [; F       LED_1_REV;    //LED翻转) x/ z: F' a0 A+ M
      Delay();       //浪费时间
* Q$ u/ S4 i! m' h- y9 c/ J }& k9 g: F* y1 Y8 B0 z4 f- i8 x
//DMA传输结束后，自动关闭了DMA通道，而无需手动关闭) m5 |- g" f' ]2 J" ~* Z6 h5 n
//下面的语句被注释, `# \1 Q7 v4 x; g
//DMA_Cmd(DMA1_Channel4, DISABLE);4 b6 y' m* ?0 L  a

: y2 G: q  U5 N8 U7 W  Y printf("\r\nDMA transmission successful!\r\n");
5 O. A0 N9 w3 f
- \: }; c0 j7 M6 k8 U% B0 r
5 @& P4 W  A/ e$ |$ h% x# ] /* Infinite loop */
; o! B4 m0 s+ i7 A while (1)
. F" u1 m0 K3 ~: q$ q1 Y2 ? {
# ~6 t2 F( j$ p/ t& Q }
) _% g2 \! y  u5 r}
1 q8 i  K% F9 P+ }* H# k/ f9 g! x1 A# j( `# O' E* e
/*******************************************************************************
1 r& N! g! p, j3 x4 D* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)7 R( T, ]0 J* L& c9 {
* Description : 串口发一个字节( A& d" E, F" ^1 S
* Input       : int ch, FILE *f
5 l7 D$ q% \4 p9 s$ {9 L* Output       :   o  D0 p) M; D. w+ K
* Return       : int ch8 H/ P& s! l- w9 |: F5 Z
* 这个是使用printf的关键% N  z: S5 u7 `% ^
*******************************************************************************/9 x# S2 R2 {0 Y
int fputc(int ch, FILE *f)
+ X9 r# ^6 w  T9 U% A! P* ]! x& @: u{5 [. [2 x: {4 J$ e* f& m
//USART_SendData(USART1, (u8) ch);
5 y0 l1 O2 k2 d% U/ K USART1->DR = (u8) ch;
4 ?) @( r5 |6 _3 {9 [. A   b+ F  r2 n2 N! I0 V6 g- _6 w- {
/* Loop until the end of transmission */
: b4 b5 o  A6 j) q5 {" O+ w+ X while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)0 D; n( b% r) P
{
' h8 n0 O' w# T- q! C }
) A' T% W" v% \7 E3 j& M( Y8 c5 I- e& g& O* `( k  X
return ch;
" F5 ~0 d% g/ p}
" C4 r: R  n. e/ J
( ?+ E6 l* ]4 A2 z0 s3 ]/*******************************************************************************% a) l( s9 V2 j; P  w7 [
* Function Name  : Delay6 ~( ^5 j6 O- r+ c" t; Z% x
* Description : 延时函数8 I# q, Z" i% a
* Input       : None$ C9 l8 Z* h% v1 W- c  Y; C  ]
* Output       : None
8 y; y( }0 o5 W4 [2 K# C# C/ {/ d* Return       : None
  U4 ~  C+ ]  Q" F& H/ C4 U*******************************************************************************/* I" ]/ M7 A- I; H2 s2 g, ], S
void Delay(void)
3 i/ s# g* D0 N- L; z  }+ D  Y- c{
# ?; G. L6 U, ]) T% C u32 i;& z# v3 `3 R& T4 v% o4 \" N/ M
for(i=0;i外设. S3 O7 S. T/ m( P
//每次传输位：8bit+ I9 b3 U0 C/ o" b9 B% P
//传输大小DMA_BufferSize=SENDBUFF_SIZE( ~/ |* X9 j* r  Y* N) k- ]
//地址自增模式：外设地址不增，内存地址自增1
. M; m4 L4 @& l/ S //DMA模式：一次传输，非循环
* N+ w2 M3 ^; k //优先级：中
0 e4 t* h% Z5 b DMA_DeInit(DMA1_Channel4);8 w* |# v5 x+ o5 L$ C+ d2 ?9 N7 Z
DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;+ m( u+ U$ P: F+ `3 z/ y5 }" x4 x5 B( w
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
1 T0 S7 ]9 l5 } DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
! _3 j- m) n; J; E$ e5 [  k DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
5 U. L2 T* p9 h8 e, n6 G DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
7 }6 h: |: z/ p8 ] DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
, s9 J6 B+ ^  q3 e& R DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;2 Q" Z" {: ~( x& c
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;% n9 Q' ~% |' O! b: G+ }
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;  F# ]. {  J% v+ Q2 u& X, }6 X
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
2 r& L! o( c- [! _. r% c8 N DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;; u# ^. u9 I, w2 r5 a5 F1 a
DMA_Init(DMA1_Channel4, &DMA_InitStructure);# f, E- O( A# m& d4 k
}

赞收藏评论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发表:/ u+ Q# ?/ W% W( _7 _) Y" Q) ~# [5 c
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。
  Z/ B# {5 p% N, e- F/ H　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
3 _! o' \; u8 J' V5 n7 h  C3 |　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
' c' X7 O+ V+ m1 P　　这个是相应的代码例子，基于STM32F103VBT6- ?! w5 B, {7 I9 a+ v" [
6 T# ^/ q) b( e5 e

1 b5 x4 J4 h. P' ?8 o/******************************************************************************6 r- E. i$ E: ]& l$ H" p# @) c, M4 ?
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()
, v/ l' x6 y  ~) y* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输3 n/ q. E6 J4 T$ N
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
) l) g: J- G) G5 ?* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART- N  @: q5 {0 M. a" ~
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可* f& ~5 k5 K5 D6 C1 ?, n8 ]7 B: D3 j
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止9 [, b. ~. F$ n  C
* 串口依然发送，表明DMA传输是一个独立的过程。4 j. T4 s: z. }# e
* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理
# l1 A* S+ Q8 r* 作者：jjldc（九九）+ D" F' h3 @+ s
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6
9 H1 a4 D3 b! u*******************************************************************************/0 @; Z6 p! l6 _  w: z1 t) U
" A, v/ P* O" T% j
/* Includes ------------------------------------------------------------------*/
% ?. k$ R* o4 ]: v" u  o+ }1 v! }#include "stm32f10x_lib.h"  w! s2 H0 V# f3 f$ f
#include "stdio.h"* z, v* c. N, h1 w0 U4 b- T* ^  q

7 U- v7 _9 A1 s6 ]  y" s8 g4 u/* Private typedef -----------------------------------------------------------*/) x& W3 ^" t* U
/* Private define ------------------------------------------------------------*/6 [) O$ ~; \# {: h1 ^4 A9 V9 W
#define USART1_DR_Base 0x40013804
* F5 \/ S- X7 d, [/ V9 B
+ i( }3 S! {2 f' B6 R& g0 X! a/* Private macro -------------------------------------------------------------*/
9 @! \0 s5 H  y( r9 u5 F5 u7 l/* Private variables ---------------------------------------------------------*/, V- \; @7 E# g
#define SENDBUFF_SIZE   10240
vu8 SendBuff[SENDBUFF_SIZE];5 c9 g6 D0 s0 N$ c- b$ k  a8 S
vu8 RecvBuff[10];
( O% m+ N# g3 k9 m  B. Rvu8 recv_ptr;: t, {' y5 F# E; c* H+ j* N
1 }( b+ F+ \* E! \& W, y; R
/* Private function prototypes -----------------------------------------------*/1 e+ q& R  o% }. b, J
void RCC_Configuration(void);: N$ v8 ]5 t( e( s
void GPIO_Configuration(void);
/ @- Q" l8 W. G4 P% Cvoid NVIC_Configuration(void);0 R; K  K3 A' n
void DMA_Configuration(void);' {( w6 x- P( J1 z0 {- a, J" x0 `2 c
void USART1_Configuration(void);  h$ v" H0 @5 e1 \0 }) a* |$ Y  y

: R& S( w2 t+ B, ?4 Sint fputc(int ch, FILE *f);
! X+ K3 Z' U+ M" P: R3 ^: rvoid Delay(void);
3 a. n! s$ f4 A; E3 d/ F. e% R, x5 J+ g3 e& X) T
/* Private functions ---------------------------------------------------------*/( I; v% L/ i& i/ f. y
/*******************************************************************************$ @# P' E" E0 b
* Function Name : main4 m8 N, M- R8 v( c
* Description    : Main program.
9 S# ?/ R4 t5 {. L7 ?  T2 H7 A* Input          : None8 U& z6 w- V; J
* Output         : None
1 h) t1 O! F% y" Q' k7 h4 y" O* Return         : None% z. H8 {4 O1 Q9 [  n" m* C2 _. c& ?' ]
*******************************************************************************/
6 m( p! y) v, ]int main(void)6 b% p8 Q3 A* l) D
{
( M: q% C, W0 T  P9 W$ I+ d    u16 i;* `6 |* i: T# j* N, Z! E- P
#ifdef DEBUG
, }) x$ N3 Y& o: G; w    debug();
/ U# c& ~2 y- _# F* U" R#endif
" ^9 O4 q& u$ c1 O" }' j' [2 w" W    recv_ptr = 0;1 q2 q* @: R% w8 T, K

    RCC_Configuration();  X, W0 [& A' K2 m, g
    GPIO_Configuration();4 o: m& h" b. X4 P$ \0 B- }! O
    NVIC_Configuration();
+ b8 ?, t. v' R! i4 n1 L2 r3 G    DMA_Configuration();: L& A* k+ `+ D9 _
    USART1_Configuration();% _- h& a; \" w0 N9 D6 {4 ~* X5 f% D

( X( h+ _$ S3 R' {' n    printf("\r\nSystem Start...\r\n");, ]2 T( _5 j2 D( O2 F
    printf("Initialling SendBuff... \r\n");/ {, N) N4 s' t* _. S. n; }1 z
    for(i=0;i    {
- d) s$ m0 n! ?; o% m" z% v        SendBuff = i&0xff;
5 f2 t  I' y- Q  P1 z3 Z' L    }
% M; p, |' _4 \0 [5 y2 i    printf("Initial success!\r\nWaiting for transmission...\r\n");. O, {/ i4 [" p; M
    //发送去数据已经准备好，按下按键即开始传输
2 i6 t+ _- f4 G    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
, k- L! D7 ]1 o7 S7 y    - a8 N* F0 b2 f/ u+ b+ _
    printf("Start DMA transmission!\r\n");
0 [8 i' l  H! ~/ X! b# r& V9 f    3 \: R# W( e5 ~6 O: ^
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
" l4 M9 c; G& k' }+ E8 X. \1 {    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);0 S, w! Q1 @7 D4 w5 ^
    //开始一次DMA传输！
/ {1 z) i' g% u    DMA_Cmd(DMA1_Channel4, ENABLE);" x& U/ y& N5 ~
    ) I8 ?5 c- l9 M( ^( d, G& u' f0 C/ L
    //等待DMA传输完成，此时我们来做另外一些事，点灯
/ U( m. w$ j' h0 ]3 T" W% L* f    //实际应用中，传输数据期间，可以执行另外的任务0 Z( a7 e1 g. M5 {
    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)3 _# i/ D9 Y8 H! M; P6 C3 N
    {0 |9 P2 I' r7 a, s, m; v3 E5 L
        LED_1_REV;      //LED翻转1 k8 E2 W+ o4 H) M3 Z) |. V7 N' y
        Delay();        //浪费时间
- t, \' P* Y# \) c$ ?    }) F# @6 Z" V, A8 ]3 V
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭# i' @: U2 I0 a) _! ]
    //下面的语句被注释# n) R: g  V9 o% z1 l
    //DMA_Cmd(DMA1_Channel4, DISABLE);9 e+ R+ X6 |  f8 K; \1 b8 T7 u
    2 y1 c' h& {1 |+ s, k
    printf("\r\nDMA transmission successful!\r\n");. r' O/ U1 \0 u
$ Y8 }/ G8 w9 k. G1 z, h$ i5 P2 M

, A: ^( \7 }4 o& P3 V    /* Infinite loop */  e' n% n3 z0 B: ^0 A; @
    while (1)
* B9 [+ ~8 C/ J# I7 G    {. j) M4 m* O9 c; c9 p/ r$ M
    }
6 z6 x, ]% J3 N8 F}4 V$ o' s4 f* k1 ]& e3 s! M( R: Z

! v5 I! G* @' Q, H0 Y" ~/*******************************************************************************
: O' r! p$ G2 g6 M( M2 x* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
, X1 m; m3 y- w( ?( n* t) I* Description    : 串口发一个字节
& q$ j' E, q  @. Z8 d! R6 G5 B* Input          : int ch, FILE *f
: `- R) k1 D. K' K3 U' `* Output         : & ?8 e4 R% z* x
* Return         : int ch# C% u/ @; f5 A+ ~5 p$ [: Q' c& _2 s
* 这个是使用printf的关键
, f5 h; Y# ~( Y4 B# O! s*******************************************************************************/
8 K, E6 p0 t9 e' l# E' X  t+ qint fputc(int ch, FILE *f)" Q2 K- Y2 [2 B# f0 ^1 y
{% r* i5 S2 `2 U- Z- }4 N. L
    //USART_SendData(USART1, (u8) ch);. p- b, c; }; u7 O
    USART1->DR = (u8) ch;$ f6 u% f7 B' `" H% }/ X) }- g& x

: x( \# Z0 g- I7 w+ o    /* Loop until the end of transmission */3 D/ U+ r. ]. r" q$ R
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
4 q* c# H/ F* M    {; f& m$ A! S. y+ Y0 ^9 W0 A$ e
    }
8 |# k8 v) J/ _  ~0 I) c/ |/ m9 D6 }, Z  f) Y& \
    return ch;
) ?5 R% D$ [! n; V}4 i$ j, G$ Y/ O' ?1 x

  F! [- b- n, F4 M7 y/*******************************************************************************9 w9 b" m' p7 I" X
* Function Name : Delay6 t3 W) K6 c4 Z$ i% p6 h/ d# E
* Description    : 延时函数# F! g% N+ \( F9 d& w
* Input          : None
* [* u) O# I& E* Output         : None
+ }( t3 U, L* ~' n* Return         : None
1 ~) x1 x  O4 f0 ~2 J*******************************************************************************/
. d6 H9 n- R0 z" `: \void Delay(void)
( `& a" |* r- e/ T{/ L  @6 U4 k$ Z% T
    u32 i;3 O8 Z5 Z( c; r& i* ~
    for(i=0;i外设
" Z5 x2 Q$ |& x- N* T    //每次传输位：8bit' c5 c% B% ~; S2 z4 ?- P, `- s
    //传输大小DMA_BufferSize=SENDBUFF_SIZE
$ t: b; y# _, U    //地址自增模式：外设地址不增，内存地址自增17 N. ~3 M% O" D
    //DMA模式：一次传输，非循环1 f* V& w1 c$ x9 C3 D9 C# \4 {
    //优先级：中7 V4 Y- o6 w. V+ e
    DMA_DeInit(DMA1_Channel4);
7 d9 w1 c6 |7 ^7 W3 m, ]9 Q3 M    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
. z! a3 i$ E' G) Y" L+ m6 g    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;* M" z3 ]$ ]/ |' o
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;* \8 ^' S% F# j! J' \
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;2 u! y# n; Z& G1 N: k
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;& m& j9 N; R4 Z0 K
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;# I3 T5 V3 ?: x! n6 x* H
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
# h. f; f4 X8 X) d    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;# k# B3 m/ y+ K& @) P  W
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
1 a8 {1 i, K# M' `$ N- j9 y    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
2 K  O0 E) b# S- u    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
5 m5 h! {  b' @: `" K2 Q! M    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
7 R( P& ~: \9 ^& J}