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;
% M0 y( `- u3 v2 [$ H; C4 q }6 @  _0 H- P/ s% I
printf("Initial success!\r\nWaiting for transmission...\r\n");
' y4 L$ V. _  a2 J8 N2 R //发送去数据已经准备好，按下按键即开始传输5 P2 o4 p! z' x5 _' ]1 Q5 X5 V! M( Q
while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
8 \; u$ n& D7 l8 ~2 l/ }
0 ?6 }2 y" k9 ~9 ~: A0 y6 i/ U printf("Start DMA transmission!\r\n");
: i5 q% D2 @$ E& F+ r
9 w2 ]3 Q) n5 g: U6 i0 | //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
8 R: q8 M0 ]# |$ v2 s2 ^" z+ @. ]$ R3 F USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
7 j! j4 Y& V! j/ u //开始一次DMA传输！1 j' t% D+ H9 Z
DMA_Cmd(DMA1_Channel4, ENABLE);# R# r- g3 K, N8 g9 ?. x  M. F: A( C

) F: r! J% c$ V+ |, B* c5 k6 Y* n5 A //等待DMA传输完成，此时我们来做另外一些事，点灯
, r( C/ a  L* K8 G //实际应用中，传输数据期间，可以执行另外的任务1 j5 |7 L+ I3 L  t  P4 f! @
while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET); Z* V( [; }+ M' e- q! d3 l# U
{. `0 {  z4 u6 J0 ~" \* K+ q
      LED_1_REV;    //LED翻转# m5 \7 t; u$ d
      Delay();       //浪费时间! _' h/ I$ e' ^/ P. b
}
. N0 W$ D' U( O+ e7 V //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
/ x; m5 c' f9 p1 H- G //下面的语句被注释
9 j( S: M  d1 k6 j1 d/ r //DMA_Cmd(DMA1_Channel4, DISABLE);6 u; e) L# D4 q
- A, }. w! H1 k
printf("\r\nDMA transmission successful!\r\n");  o7 Z# C5 m- T! Z+ o3 y! f
1 P- C$ L( G; c4 ]- c" {- `$ F2 @
& p  y: z. _' E# S
/* Infinite loop */9 w, F* f# ?' V# g4 g9 t
while (1)
6 n) ?- l( \; R7 n# c8 S {4 w) E+ q8 |0 E% E8 F
}, T. m. @+ M, z% R6 O
}
2 u- G* ]. Y  [- M0 n" n" u/ n4 O( `: T+ C6 n
/*******************************************************************************$ X9 m8 `% x6 z" Q' e* g
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)# T4 R$ p2 |. k
* Description : 串口发一个字节, C$ }, C1 S- o/ F# c' ^# b
* Input       : int ch, FILE *f- _6 A; k/ Y4 D. K$ E+ N* e, k
* Output       :
1 ~7 b' }1 v; }) |. M1 B* Return       : int ch- J) i$ ~# b. |# F: g. J
* 这个是使用printf的关键! g' ~7 J- D; v& f
*******************************************************************************/5 C5 E5 s6 n# r; r4 d; h
int fputc(int ch, FILE *f); B: i( j& E( H: T0 n
{
' A6 @4 @/ |; u- c4 o9 [0 j: A //USART_SendData(USART1, (u8) ch);; {. b* A7 {+ _
USART1->DR = (u8) ch;3 R8 e; W" r4 F+ h

) C' z3 f3 W0 q& J& e/ x+ @3 ]+ Y /* Loop until the end of transmission */% x# }, h1 n) l9 w* V. l( A$ T
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
) b" j6 ]& @+ ]. ?/ j8 h {
( t3 o  l) p( G! j, M! \, u }
7 C  J( Z; W: y" y% U5 n: L/ L0 O6 x7 N) n
return ch;9 o9 r, y) {7 Y; Z- W; S6 g
}: S+ _) O3 q( n; ?, a

: Z$ _% E2 I6 L9 S5 i# U5 k8 l/*******************************************************************************/ U' A" n- ]& S2 K
* Function Name  : Delay
; F/ G7 M. \) n; }- m9 n; d* Description : 延时函数
- O( y0 j6 F& m* Input       : None( x6 B  _9 W8 R: M1 b( e' Q- V
* Output       : None
' l% C( ^" g2 g# _+ U3 u/ J$ Y2 f* Return       : None( F" W0 c0 E0 _
*******************************************************************************/
0 {8 L; t1 L5 [& |4 |3 s% evoid Delay(void)( J* J5 d$ N! W$ f& A1 I2 Q) ^
{, S, p6 A9 f4 t
u32 i;' W$ `' Q! f  @0 r  _
for(i=0;i外设
! n) O& |1 K$ }- j! a$ [5 m //每次传输位：8bit+ i) q1 E1 `! {9 U
//传输大小DMA_BufferSize=SENDBUFF_SIZE$ m7 T2 O  s& t1 T. M
//地址自增模式：外设地址不增，内存地址自增1
# @6 e& b2 d* V0 T  Z& `1 K% {* X //DMA模式：一次传输，非循环
- k+ I" I- B3 J //优先级：中
0 g$ m! C1 s( u. B9 q! h DMA_DeInit(DMA1_Channel4);- @3 N5 w/ A! a5 f( \0 r# c9 W2 N
DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
5 B$ U) w$ ~2 o0 |: _9 u DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;0 \5 M8 Y! k2 [. V1 W
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
+ E! U0 k. p" Z5 }; q- z DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
. L% F5 [1 f% O, H% A# p DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
# u5 }; `0 U+ P; D- } DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;+ Z1 J$ s. t" s" M
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;9 j, i7 j( o' o( h; F
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;1 |& |8 N3 X1 G2 A9 v) v
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;* t  h$ @- x' _2 R9 @# L
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
5 D  z7 V  ^: \) V DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;& |7 X6 G) G* j5 \- Y) [
DMA_Init(DMA1_Channel4, &DMA_InitStructure);1 i, T; _7 v7 _+ w& _
}

赞收藏评论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发表:
2 @5 c: o1 k7 [8 H2 y. I　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。
* N$ ^5 r+ Z' K. b( `7 j　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。8 m# G8 e+ h& }, Q" G9 g
　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
+ v8 T& P1 q, f/ `  g　　这个是相应的代码例子，基于STM32F103VBT6
5 z+ s+ _1 k+ G# j  a5 T, k: H/ r4 D6 t& ~, k" V' ~" J: ~
* c# I( X( C# |- |2 `8 U
/******************************************************************************
, p9 j" s- x% K: e7 R* N* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()+ F5 B1 y' ]5 m1 A; x2 Q6 |& [
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输
# E  y2 I8 J5 y) E* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
0 S  F- I5 ]8 P7 |, V* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART
. L! o* X' z( S7 P, i- v* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可0 `4 K( d/ e, d5 u9 z
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止; O+ d( l) \! e9 C  c- p4 C" b; C  b
* 串口依然发送，表明DMA传输是一个独立的过程。
) ^4 I- {; h3 t# t3 J* z. c* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理+ r6 w& \6 @3 l* W
* 作者：jjldc（九九）$ m$ c* R% b# ^. d0 V' e
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6
; ?1 s8 s8 [- O*******************************************************************************/
+ F# r1 P9 D9 ~! T2 [8 r8 U
$ g* n0 X* i; z3 E# r+ V/* Includes ------------------------------------------------------------------*/
% i8 c, k* `& J6 Z#include "stm32f10x_lib.h"* B( Q, w9 Y1 H
#include "stdio.h"
0 B) W* ?2 Y4 F0 P& h
$ A+ _4 U/ @1 P/* Private typedef -----------------------------------------------------------*/7 z- h" h8 }$ e7 S# G& k9 _( e
/* Private define ------------------------------------------------------------*/
- K7 u7 T2 R1 p$ o+ V#define USART1_DR_Base 0x40013804
4 t4 B9 _7 F9 _+ p$ r4 Z1 `
2 ~) Y' B4 i% B0 \/ C: M/* Private macro -------------------------------------------------------------*/$ ]* C$ V2 ?# V4 u$ s( ^
/* Private variables ---------------------------------------------------------*/
/ N0 ]+ S, }/ l  x+ {#define SENDBUFF_SIZE   10240
2 f! A. B/ l/ j8 B+ M9 Jvu8 SendBuff[SENDBUFF_SIZE];2 C9 J8 o# p: u3 F: x8 q6 a
vu8 RecvBuff[10];# i/ i, Z8 Z( ~8 ^
vu8 recv_ptr;
/ D+ i# G7 [+ q* A
3 P1 l- D7 N& I' H7 X/ A/* Private function prototypes -----------------------------------------------*/0 n3 F  N* X+ A* L1 g: L% e% \5 [
void RCC_Configuration(void);) V4 x% J* Q% x+ `& U3 P1 R% @: `9 r" Q
void GPIO_Configuration(void);
; \! n7 `) s5 d# ~6 q- ?void NVIC_Configuration(void);& R0 n  j" E1 q, i" \3 j
void DMA_Configuration(void);
: F5 s  o/ G& Avoid USART1_Configuration(void);7 Q4 A7 x4 h( B
' ^1 S+ d8 D( I) {# h9 Q* x
int fputc(int ch, FILE *f);
, T6 A) M; g/ P3 K, `void Delay(void);
1 R/ p- I- _1 o+ [; A: B" b4 l3 r% `
/* Private functions ---------------------------------------------------------*/
$ c3 b4 I7 `! A2 J/*******************************************************************************3 \- p, k: b1 a, B) a' K3 h! |8 C* v
* Function Name : main4 c# X6 U( M1 m2 N  Y8 k
* Description    : Main program.3 {) r! u8 C0 |7 f
* Input          : None+ J9 L% t+ }9 ]% s5 _* i
* Output         : None' R1 K/ m5 k- n2 ~- u3 x) {& x
* Return         : None
$ t. |' d1 a' w9 R, h5 c*******************************************************************************/
' d, o& _# o- iint main(void)0 j. }* t* c4 e5 t! d
{6 `) y* W+ {+ L
    u16 i;2 s$ r0 U1 G) c$ Q5 q
#ifdef DEBUG
0 E4 a" M6 X' m. [* J    debug();
) o7 h6 Z" ]0 V; _5 L0 e$ P3 d#endif9 l$ F' w3 _5 n3 u$ T- e
    recv_ptr = 0;
. ]  P+ _% O* _* U    0 W1 A0 d* q# S7 l0 s* U7 U2 m
    RCC_Configuration();
" t$ G) C8 P# w3 x; w/ _2 M8 E0 c    GPIO_Configuration();) S- N" q  Q0 p  t; `  s
    NVIC_Configuration();
4 F# o5 ^) X# c0 Q' A# E5 y    DMA_Configuration();
/ B7 `+ g" t( c- b' \2 S7 x7 z    USART1_Configuration();+ T" b3 J( v/ g: c
    , T  ?3 r) d. x0 G/ g( p' i" ]
    printf("\r\nSystem Start...\r\n");6 I- |1 Q: Z5 o6 n0 m
    printf("Initialling SendBuff... \r\n");
& |% |% F& D- M; B+ l" P7 M( Q    for(i=0;i    {& p* z9 a9 M. Z* }8 n7 S( `
        SendBuff = i&0xff;
" d+ q7 @2 [' J    }+ Q! R% E% F, x; s
    printf("Initial success!\r\nWaiting for transmission...\r\n");# A5 u# `. [* a3 z! s9 z9 v3 {$ F
    //发送去数据已经准备好，按下按键即开始传输! u" ]' Z3 r( ?
    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
! J4 @$ s9 @9 ]- B6 r5 ~3 ?) X- B
% H2 Y$ h2 ?) T    printf("Start DMA transmission!\r\n");
. z+ P! J- I7 l# i4 H4 P! x
+ h0 {# P7 h$ h" }1 F    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作+ W# L) k- _4 G" D  Q- e
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);  v3 c0 q  W& e6 s+ R
    //开始一次DMA传输！
: e% ~, x9 z# S3 Z3 ~" t: R8 G    DMA_Cmd(DMA1_Channel4, ENABLE);
( R# q6 R0 X- y, i    6 B. E7 Z9 a7 h1 R8 c
    //等待DMA传输完成，此时我们来做另外一些事，点灯
, N' z3 Q- Z7 u, `/ p. Z  P    //实际应用中，传输数据期间，可以执行另外的任务
; f$ |( b2 e; x9 {    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
; j2 ~, f- _: _1 V- @& A$ f: J3 m    {# _. w! y3 g- |, j: E
        LED_1_REV;      //LED翻转
9 \5 h. N* N2 |1 Z        Delay();        //浪费时间
  T$ R1 L* @  m- j0 A+ X* U    }/ S' I- l# ^: v3 P+ T
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
/ q! \% t" y; Q$ P+ u/ o    //下面的语句被注释% P8 d# I4 `- h6 p
    //DMA_Cmd(DMA1_Channel4, DISABLE);
2 d/ }8 h  C5 Y6 j& Q  X    4 P4 e* F( j+ z( t# ~/ g2 H
    printf("\r\nDMA transmission successful!\r\n");8 I6 l4 c8 l% a, o' t6 e

- Q2 h8 V3 U. z; s3 L
! C' {7 \7 y* }9 V    /* Infinite loop */
! S& V8 u/ P* W3 S3 W; m    while (1)
1 K* F# F5 _, l& e* q    {
4 _5 M* Y0 @: E1 z/ D    }/ X1 W" z) k* |) S9 \$ F
}
, d2 h* l" }( Y* z8 N+ u# \
3 ?9 s7 j4 r- u( C/*******************************************************************************( W. R! `: K" `! @8 g& }) j8 D
* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
1 O% l5 L: a( W5 ]  \* Description    : 串口发一个字节4 S# I/ [" H2 j9 C2 y) ~" x
* Input          : int ch, FILE *f% q  ?9 f* D+ b; w3 N
* Output         : 0 K" w/ L0 ~2 O: a" m& E( Z
* Return         : int ch2 r6 P( M$ x0 p4 Y2 [
* 这个是使用printf的关键5 a# ^- n0 {$ O) F, `0 B% U
*******************************************************************************/$ C! @3 j8 t7 F2 G( U5 R6 E3 f
int fputc(int ch, FILE *f)1 R1 ?- t2 H( x- L
{
! O1 K  k6 R; x4 r) B* _8 ~    //USART_SendData(USART1, (u8) ch);
1 J1 o9 ^' K3 u' M; s: F    USART1->DR = (u8) ch;' c9 |0 o: l( S
    ; x0 R8 Q+ N, p# s" r
    /* Loop until the end of transmission */
8 Z8 Y4 }/ O5 L% y$ |  N    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
4 r" ~7 X3 f8 [7 D    {
6 d2 {( v* j) a$ W+ d' m    }
) g3 c8 H2 o: w
5 T5 s! _, V5 c  X  x- r" X" X    return ch;
) h8 J2 d  z9 ?: ]0 ?) W" T4 {}
' a- ]0 i- ?  D! a' ?# u% y1 o7 U  ~. g$ P- h3 C; i
/*******************************************************************************! }' Z9 B1 I# C) @
* Function Name : Delay
$ Y1 J* P7 w: [8 J: V, G* Description    : 延时函数
" _, K" e2 C4 C* Input          : None
' S, w- r# n+ B* Output         : None* |$ _5 F& [! K& ^4 B
* Return         : None6 l3 P7 z$ n. V, a1 m( h# F2 S
*******************************************************************************/
" o% Q# S; B" Pvoid Delay(void)+ ^; [; W. h$ A0 T! F2 T' }2 ?3 r
{7 F( ]% W; A5 L
    u32 i;
# y7 l1 V$ |# f2 _  J* B    for(i=0;i外设+ U; K0 H+ ^' q# n  ~, t+ q) ~
    //每次传输位：8bit' n' K! U% e6 P8 \: A( ~
    //传输大小DMA_BufferSize=SENDBUFF_SIZE
% O  G2 x5 @, o  Z% T5 k    //地址自增模式：外设地址不增，内存地址自增1! E: h- a1 I. k" _' n- Z  ^
    //DMA模式：一次传输，非循环* R. D) m0 }7 y. K2 t+ F) O: [
    //优先级：中
1 R! N0 T& P3 t% ?; V9 r    DMA_DeInit(DMA1_Channel4);& K0 J  H) y/ q' e# _
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;+ g3 e9 b1 C1 b) R+ W' g
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
8 s# ~1 d% X0 e) h! C# m) d% F; V9 s) v    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
# H  ^7 T/ Z7 z- c. [0 |    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;+ k- N4 b4 X" i
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
: `0 u' W9 M; G5 R" d- N! F1 W    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
; W$ g. Y" N% R$ a/ ]3 f3 T    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
6 L8 ?& g( k* ~2 \    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
% S8 X* j+ ]' s" Z# A    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;8 a% p- J7 g* z
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
; Q# Z7 Q7 E' h: A! ^7 g, M0 x    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;, M. {- D' A& D5 H  z( k
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
, R- E8 c$ z$ l, k2 r}