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;
. k3 }* T& G+ X- t7 e }
, n7 t9 ?4 s0 x" Q printf("Initial success!\r\nWaiting for transmission...\r\n");
( N' G! F, a  x! x6 j //发送去数据已经准备好，按下按键即开始传输
5 x& R  m  R: C7 a/ n while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));% }! e7 Q1 T  S% p! x/ _) n. c7 a
3 W! Y" V/ e2 n& J8 `3 J$ @5 Y
printf("Start DMA transmission!\r\n");7 s# j" V, l" [9 g* P' a5 T# N
4 i$ _$ U+ i; y- h% M) `- X
//这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
* S1 Y+ {4 P" o! W1 N+ o. P; h USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);+ ^3 ]- R$ b' @: c9 m0 e
//开始一次DMA传输！9 p9 w6 s' \% }; k
DMA_Cmd(DMA1_Channel4, ENABLE);1 u8 c1 z+ J' y9 r3 O- u0 [  j

0 o+ C8 T, Q# |1 l- |1 G2 Z8 T% b2 S //等待DMA传输完成，此时我们来做另外一些事，点灯
: x3 |1 d8 ~, F2 |6 s( D' @3 b4 b //实际应用中，传输数据期间，可以执行另外的任务
& j3 [7 o+ Q1 }6 ^2 n8 r7 u while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)4 \$ `5 t- U2 G2 j# T, L
{
, I" $ X  L4 c5 Q- Y- F+ N! U       LED_1_REV;    //LED翻转* I7 I. u* P. o  v& h5 ^* c
      Delay();       //浪费时间
3 B- Z4 x; N( n( b' y* A! e }5 M. R4 H: E1 U1 S" c- @: c6 Q1 K
//DMA传输结束后，自动关闭了DMA通道，而无需手动关闭, X9 e1 J( k" Z% D( N8 S$ x) G6 F
//下面的语句被注释+ A# V$ r+ `+ \2 s1 M& B5 h
//DMA_Cmd(DMA1_Channel4, DISABLE);
- t0 @6 f7 b" a( g
7 E7 v8 a. W" ?  $ R printf("\r\nDMA transmission successful!\r\n");
* o; W$ u8 A. |; C4 D2 a! ^7 c+ R: b  Y/ D5 v7 R( W: T) x# p

) l. a! }( x" C1 w: I /* Infinite loop *// j1 B/ ^1 F  M: s; b! T
while (1). L  \3 K+ N  o& E$ C
{. o: ]8 K3 f) l% e
}
5 J4 s1 [+ @  Z' J+ R5 Y. K$ d}
, @1 C1 M7 ]: |* P6 R; @- j! V8 R9 r. U' ?% A
/*******************************************************************************, B! o' U. j' f1 Y
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)
( t  v( C7 C' ~7 \+ a1 h! u) u* Description : 串口发一个字节
1 f% d% F$ T. q# E* Input       : int ch, FILE *f0 k: s" u# [! u1 d$ B- T/ ^
* Output       :
6 B- Z/ J/ h3 U* Return       : int ch. _5 s/ k" X4 s! d  T% v
* 这个是使用printf的关键; Z4 P' l7 g  _- q; P. q$ ~
*******************************************************************************/
0 b9 |. B1 u6 x3 A  Dint fputc(int ch, FILE *f)
4 c6 Y) X% }; r( f6 w8 l{  w) M) H1 W3 `; \
//USART_SendData(USART1, (u8) ch);
; \9 e) c& k8 F) e: } USART1->DR = (u8) ch;
; o( {# j3 u( M# o - T9 L  P" Q# e0 s
/* Loop until the end of transmission */
" J# j5 C: k, ^ while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET), k2 v( P% K% u* X: ~# g% X8 k. `
{
1 u1 G+ o& k! K- p  ^ }3 S) U6 }8 y2 n' N

+ L, v+ a! z3 a return ch;$ Y( y; S; v; t8 p& t$ M1 E
}; Z8 ?! {+ L( p7 j6 }; @
; l, F: j/ i0 ~# `8 s' J
/*******************************************************************************
! _: |- I8 o! g) u7 c* Function Name  : Delay( b( @! J5 g  S! B, s2 Y" l
* Description : 延时函数4 {* T3 `/ f9 A! c+ N
* Input       : None' c0 O' e: q8 W5 `1 l
* Output       : None" V/ ?- J# e  n4 B7 [
* Return       : None
0 X+ [4 M8 |8 O: z8 A1 q*******************************************************************************// K6 a, p( u  x4 W! Z# K
void Delay(void)4 N$ G- |6 X4 O4 c8 ^
{
7 `; J% r; |2 q u32 i;- J' v5 n% \9 o2 O' B
for(i=0;i外设6 N7 ]( n( L5 ^
//每次传输位：8bit
- R: @) Z5 h2 P. y //传输大小DMA_BufferSize=SENDBUFF_SIZE
+ A7 [+ ]0 w3 r* t //地址自增模式：外设地址不增，内存地址自增1
" d, c- I+ U" B: M& Q //DMA模式：一次传输，非循环. l4 \4 c: V/ c
//优先级：中# E, U7 S3 ]: f  ?) E1 y& T
DMA_DeInit(DMA1_Channel4);2 P! B+ u. B! L- }0 N1 h. g
DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;+ s9 V4 O$ }. N' q2 @# g& p# r" Y
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
# v+ D8 Q: v  f" i& g2 }1 N; L DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
/ r* ~* Z5 i" y DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
- [8 C$ E* p. _. R5 ^+ d% T3 z, g; o DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
0 G6 e1 e, w$ f; Z' J- b4 Q, ~ DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;# Q( b" h9 C3 l/ {; A5 k
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;/ l: G7 X: A% t0 }) [- k( N) q
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
" y' E3 U1 i# h- \  m DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
# E: E/ c7 A, F/ e DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;# l& ]9 _% z. m+ A9 F7 @- L
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;1 u0 o" m- u2 g5 d# x7 k7 q" s
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
/ r- b0 q  f* Q& o3 n}

赞收藏评论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发表:
  k1 I0 w4 r% d7 ^- ~. H　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。/ ]0 j2 N' v/ L( K" D5 g: }9 |
　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
' ]+ N' Q# ~- U) N/ z% F6 \　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。' v9 |( J0 c+ b- q4 p' r9 L" x
　　这个是相应的代码例子，基于STM32F103VBT6
/ \/ g4 F1 C+ \" k
5 G3 R2 |) N0 a5 S
2 @1 G  X  u, A6 p/******************************************************************************& I" |8 W$ I' q% R* b
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()
$ a1 ]  o% S+ v# M8 Q5 |5 D* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输% e4 l" [8 v/ }. `6 q# Z' P
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，8 |/ \# d- o- o% F5 s+ m6 w
* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART! z9 O. ]& ^& d" }' Z5 w
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可' r3 w' R# c. H5 A; q0 O. Q
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
" _- Z/ L! M3 p- w: i5 G: ?* 串口依然发送，表明DMA传输是一个独立的过程。- w- I2 a: q/ |
* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理+ E8 f, n; z' O( O
* 作者：jjldc（九九）- `& i! i$ v- y3 u+ W% `
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6% w1 F. ]; R7 h/ n1 J
*******************************************************************************/
( p) v  c% l" @, p# F$ U
* I2 Z1 t3 v" ~+ R/* Includes ------------------------------------------------------------------*/" [$ r7 N! Q' S% x
#include "stm32f10x_lib.h"
" h+ u7 b* Z  q8 V! |; N#include "stdio.h"
% ]) u( q& L/ D8 ?5 g/ I* {3 _5 w; k+ T! I/ O; D- F8 N
/* Private typedef -----------------------------------------------------------*/
/ X8 O" z2 p6 u- F' f" G1 U/* Private define ------------------------------------------------------------*/
4 W+ w5 t7 U  ?5 W0 H4 h' ^#define USART1_DR_Base 0x40013804
7 k; m& \2 N) N2 ]0 g3 h
( |$ Z" m( z) K$ F) D9 R/* Private macro -------------------------------------------------------------*/
3 L" N# U* Z: i7 H; k- e- L' l/* Private variables ---------------------------------------------------------*/  K: O; l1 n. r4 N/ u8 I
#define SENDBUFF_SIZE   10240
" t' `- Z3 I% Y/ nvu8 SendBuff[SENDBUFF_SIZE];1 ~! _* \3 D+ {2 t: Z6 U0 U
vu8 RecvBuff[10];
9 }+ D  L& s# @1 ?* a. \2 R8 \" svu8 recv_ptr;
! G( t3 w% ~! S5 T3 i( W! [$ E& O' t( p8 d7 r3 ]) ?: i. \$ f
/* Private function prototypes -----------------------------------------------*/
& @* p! w7 {  M  [! uvoid RCC_Configuration(void);9 W8 a- k( f5 G4 e* o. l
void GPIO_Configuration(void);
: u/ A- r, s/ T& z( Y% Jvoid NVIC_Configuration(void);
. u0 o- ~0 M6 v0 S% qvoid DMA_Configuration(void);- g# Z- R) d% T2 {3 B" F
void USART1_Configuration(void);
8 `" V6 ^8 R; J3 p5 f4 u/ W
5 b1 A5 {: x4 P3 t! |9 N9 ?/ lint fputc(int ch, FILE *f);
5 V% q& W' f7 d1 M/ Mvoid Delay(void);
, f& e* Y1 r" A5 x- |4 {
  v8 w& l% L+ M, Z# D: H/* Private functions ---------------------------------------------------------*/# s- y- A) {& x0 h0 T, _# z
/*******************************************************************************
8 W8 Y8 T8 f) E8 y8 k* Function Name : main! k6 a$ f# D# u" m; |/ i
* Description    : Main program.
% c5 k4 I+ C" h6 R1 j9 G* Input          : None
% P" a- }. ~$ ]) @* Output         : None
4 v) L# q" d! p4 G' i# A: ?; Q3 G* Return         : None
( n* b) W3 y- L0 v/ W% Q7 L*******************************************************************************/* c2 V6 i5 c2 J8 m
int main(void)9 L2 a" R5 Y  f
{
( S/ f8 X+ M; }" x8 S& Q    u16 i;
& E2 k. I! q- |( h- F0 ]& s7 K#ifdef DEBUG
" N: C$ l, {0 M, r1 Z$ P1 s$ e" [    debug();  S& v2 s* _2 T& }* }4 N
#endif( f: h, T6 d( J
    recv_ptr = 0;
5 n1 i7 C/ e* j# P    # F+ B' H3 E5 F! D" m* O
    RCC_Configuration();
3 i& C6 B8 D" t, S; ^    GPIO_Configuration();/ F; B# W% J, `; w
    NVIC_Configuration();% i4 n" p4 O1 V! @$ A
    DMA_Configuration();2 K) v4 t& W3 P# x$ k. p
    USART1_Configuration();0 a7 x; f, ~8 ?' Y. j8 K2 ^  h
    + M, }/ G* k& n: \/ L$ E% M
    printf("\r\nSystem Start...\r\n");$ I* f( g  J4 k5 P: j
    printf("Initialling SendBuff... \r\n");! _4 Z/ ~! ^  G) x
    for(i=0;i    {2 K- c+ }* a! b% d2 a
        SendBuff = i&0xff;2 H/ d# h' M2 _. C) g6 o' S
    }
/ ?' ?+ l. G% X    printf("Initial success!\r\nWaiting for transmission...\r\n");7 c# [% [' i) M6 u/ a5 Y
    //发送去数据已经准备好，按下按键即开始传输/ v0 q" ?" O- ~1 _& k8 s& T' }
    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));& x2 ^% ~9 r- ?( t3 S7 H
    , w4 T( l, G9 ^5 g' ~
    printf("Start DMA transmission!\r\n");* H3 i# L" J/ a2 h$ K: y4 v
    $ `, O+ i6 Y" J+ [; O- f4 u' B& Y% b
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
: R" d! S9 Y8 l+ J. @5 T5 y    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);/ f1 Y7 M: |: W4 \/ P$ ^
    //开始一次DMA传输！6 o0 F2 W# v' {' D# B
    DMA_Cmd(DMA1_Channel4, ENABLE);
7 B0 n0 a  y2 }: A2 t
! o4 i  j7 _" }& K4 e& i    //等待DMA传输完成，此时我们来做另外一些事，点灯. S8 O, y# i/ s% _5 u6 @
    //实际应用中，传输数据期间，可以执行另外的任务
& O* q9 f9 O! k; x7 D8 L0 B! r    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)* q4 E# [" p, h5 y
    {& T5 n6 _' d3 y7 s% g) u) T
        LED_1_REV;      //LED翻转2 E% [1 n6 m0 t
        Delay();        //浪费时间
% N- Y" ?4 N9 [8 X    }. m" T4 r( L1 ]5 [1 p
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭8 C& h0 c) V! T2 w+ g, {
    //下面的语句被注释$ z5 ]5 }7 G8 D6 Q
    //DMA_Cmd(DMA1_Channel4, DISABLE);& n! f. R% [, M) j

; }, r+ U" v( y' ^8 c! Y: ]6 k    printf("\r\nDMA transmission successful!\r\n");
% d$ K1 x* y" c
1 y/ @& k- A% h. f9 A0 \$ T
0 c6 s" a. S5 R: ?, [    /* Infinite loop */
5 _* ]4 |" p' y! k  N* E    while (1)
- x8 T  B# k5 [% v    {
9 Q+ C7 z1 q# O, f9 R, q    }
* V* q; J& g! \}+ b0 y7 O3 ~0 ^0 H- a  g* q
" e* w* D& n' `6 Y! A
/*******************************************************************************
2 O+ q3 d2 g( Q. L* o* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
; i1 p- X2 b5 s5 B" o) H- Z  G, X* Description    : 串口发一个字节) k' u( o1 V  X6 F6 h
* Input          : int ch, FILE *f/ e' ~  x) s- q9 b+ b: s
* Output         : ! T. ~1 K+ u) D* o
* Return         : int ch: O. Z' I$ M5 F7 F
* 这个是使用printf的关键
( u& ?: t* c6 J*******************************************************************************/
$ Q6 o  V; I0 T7 Uint fputc(int ch, FILE *f)/ H/ Y5 t1 ]0 H, m) y
{
- E9 X- H9 |+ n- Y: _1 B    //USART_SendData(USART1, (u8) ch);
, s( l5 O9 ~1 w  Y    USART1->DR = (u8) ch;
& {1 o6 f+ Y! G* c      G( l  h$ t9 E$ `
    /* Loop until the end of transmission */! d+ r) e& r2 V9 u$ u" G
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)0 J4 I; M# S& s  l7 M( |
    {
0 l3 ?" L& Z8 g4 m8 z5 Q% j    }5 G4 h1 f* O* J  Z  f+ z2 p

2 E& g  u) ^) u2 X. g  @    return ch;
* J8 m9 \% b7 {! W6 a}
+ k) t4 Q; }# A% L/ o. Y3 ]" y" s4 M9 {, |) ]! C
/*******************************************************************************4 L! S) ~4 P6 P' U! W; l/ R
* Function Name : Delay6 d) a8 J; n& M. J, f% O
* Description    : 延时函数
! b- ]- w2 ], P1 I* s/ H* Input          : None& F) G) ]4 U2 ]: z; J5 }1 V
* Output         : None
6 ~; {5 ^1 {5 X7 d4 V# K* Return         : None
8 w- R( R. n5 q& r7 ]! |*******************************************************************************/
) m8 X8 U0 L/ c& rvoid Delay(void)$ `7 Z9 {. N1 A: N$ f6 S) z, {& Y
{( e. r& k1 u; D' o
    u32 i;0 D. ?( j" G& l8 z1 |& C% [
    for(i=0;i外设2 X- T9 w9 ~2 R" Y0 I  \
    //每次传输位：8bit' E5 }9 U% R( W1 H( v
    //传输大小DMA_BufferSize=SENDBUFF_SIZE5 Z0 ], J& x; Y# M
    //地址自增模式：外设地址不增，内存地址自增1' r$ ]. o  K7 u  {. W& b
    //DMA模式：一次传输，非循环1 Q5 z, d  [6 u) @  E
    //优先级：中- e# b/ {2 [. `
    DMA_DeInit(DMA1_Channel4);
4 n" u4 g( t) [( E* q    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
) T2 A! e( H2 K0 V% o9 C/ J% ?* p& a1 Z    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
8 t. d8 S% C+ A6 p5 O( m7 k    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;) e2 s7 T1 z8 b+ l8 k
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
, O5 `7 U3 w" C$ B# _8 y, F    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
# I' X; A& {: X& M    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  L& I2 ]( n% k7 M, T    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;5 ?8 o9 T* E+ s4 V
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
: J; z  C. T' d( W7 I    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;% S- i" M$ h  x) G# x. y3 u' }% f
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
+ L9 p' W+ M/ G    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
3 {% r5 Y' Y6 F& }4 f3 I9 I  t1 @    DMA_Init(DMA1_Channel4, &DMA_InitStructure);! H; ~) O# L1 Z8 _5 a9 O' ~
}