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;
! Y5 `% |8 [4 r  C4 e }% O5 y  }3 \3 A4 B7 ^- I( e
printf("Initial success!\r\nWaiting for transmission...\r\n");) `9 h. `1 w) d/ y8 D( X! n5 T
//发送去数据已经准备好，按下按键即开始传输! H/ u- u  t# b$ }- p+ t+ d
while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
+ y3 B. w1 M) k5 q! V; T
+ w( z- C9 s& p# U printf("Start DMA transmission!\r\n");2 }+ F% v  {, m: N3 h7 H9 G
% I. i$ f. z0 n% K( e/ O" F0 E/ H) ^
//这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作3 \2 v' S8 ^0 Y0 `7 D. {2 |: u! g  i5 y
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);  \# l, }% j# [8 u5 B
//开始一次DMA传输！
9 J5 t2 E9 k% k- [, d( I DMA_Cmd(DMA1_Channel4, ENABLE);
4 X2 L/ Y, z+ U7 y
& C! O# S, h4 f4 Y* @ //等待DMA传输完成，此时我们来做另外一些事，点灯
; }$ n5 ?: Z7 v; i1 @( B* i# i- M( C //实际应用中，传输数据期间，可以执行另外的任务
5 p2 d9 e/ z, n6 a2 u while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)) J) ^1 C: y$ g
{# O( y" Y, U- B; E. ~
      LED_1_REV;    //LED翻转, r9 K& h7 i, Z& Y; u
      Delay();       //浪费时间1 @$ i1 s" M' h) S4 o9 d( a
}
" s  @1 [6 T4 l1 c //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
4 T0 \; R% b5 P5 g7 X$ C- t6 \2 r% [ //下面的语句被注释
& V, X% q/ f* X! d% J //DMA_Cmd(DMA1_Channel4, DISABLE);" s5 r- E8 c2 h1 Y: R/ ~$ ?

* X) I7 F5 e- @' s9 ? printf("\r\nDMA transmission successful!\r\n");% n3 v3 w% p- r: o% H
1 k8 V6 k% R( [( b9 [  [( {9 z
$ K1 k) K0 Y  o/ w) ~, e( D* U
/* Infinite loop */
* k" R! [- ?/ N/ _ while (1)( x6 Q1 |' l3 H
{( p( U6 u$ k0 e$ c
}+ d' k9 {( N3 N0 G$ y5 A
}
. J5 I  |  Y, l$ ]: M+ z; o0 g0 F; O; _; W4 \, T$ o
/*******************************************************************************& C+ E! _. m) }  }" N; _6 o
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)
! [2 i- g6 P7 Y3 L* Description : 串口发一个字节
5 M9 V, ]) N- K* V: z( l* Input       : int ch, FILE *f: L/ y/ G1 g% d' {2 t
* Output       :
% Y# f, o7 Q8 [1 p. G* Return       : int ch
& n& s, [5 C2 K0 U8 W* 这个是使用printf的关键! O0 X3 ~  y! d  p9 z' w' L$ ?0 x
*******************************************************************************/
0 {2 ~! C) S7 N  [' Pint fputc(int ch, FILE *f)
$ c$ k8 `+ X$ s; ^! A7 X6 H5 Q: }{4 k& P/ L% A: D. s" m
//USART_SendData(USART1, (u8) ch);4 I  s( Q' r9 |! D
USART1->DR = (u8) ch;
% i0 `1 D" ^- `8 e- G
) V7 T, W: H& J* y- l: d /* Loop until the end of transmission */4 I2 z% B; `) K5 O
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)9 u' s9 F( _  \( v3 N. ?
{+ W! \! ?8 b3 h& U! _5 ?
}, J7 l/ }& T# Y4 l- O" b- _
* k2 z7 y" W  k* U- ^/ _
return ch;
+ j! y( I/ \/ X4 v3 w}
. Z# z% t7 u% Z, U. {0 r- @( n% P, l9 R2 s9 Q0 t# U' s$ C% }
/*******************************************************************************
  s% F" H+ r& J# P! x* Function Name  : Delay
2 u% p. d7 Z$ @3 A; [3 r+ \* Description : 延时函数
; c2 e4 y' \3 S/ \/ P3 @3 J, `& }  r* Input       : None
& K0 [: ^/ L2 i+ `( \; q: ]; r* Output       : None
5 z! n& N! w$ V+ D7 _1 H. k* Return       : None  |+ b& Q. |( l. a: Z: [
*******************************************************************************/# ^, @2 o. j& p6 x2 x! t
void Delay(void)
( t% U. k7 s/ ^, R& o{
4 }" ?$ ~2 N* c u32 i;
8 A$ E3 w' c6 E8 l, v) H* L3 F+ o* a for(i=0;i外设
6 z# Y& p$ b4 \+ ] //每次传输位：8bit$ O; T+ i5 G* I
//传输大小DMA_BufferSize=SENDBUFF_SIZE& o+ |( d# [/ c6 D
//地址自增模式：外设地址不增，内存地址自增12 H2 I2 @$ G. _  R- w: G" C9 b" G
//DMA模式：一次传输，非循环" V- U$ t( p8 i0 H9 }! T3 G
//优先级：中7 `$ a# F+ I. a7 H3 d
DMA_DeInit(DMA1_Channel4);
0 X% {, _0 s2 @; D: Z DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
1 i8 @+ b1 t+ m. i: { DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
, J; ^/ M1 E9 C DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
' D, l7 w0 A! q DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;7 L- Y& m% N# V" G
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
0 \$ t6 T0 m! C3 U DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;& [' K; y# P& ~9 B9 \! ?  |* K- C( P
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
- A. r: w1 }  \0 _6 Z; @ DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;% U- c2 `2 u6 h! {# a
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
+ S* B0 ~& o+ x  A- ] DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
& G) I3 T, @( h+ l% O3 a- m2 ? DMA_Init(DMA1_Channel4, &DMA_InitStructure);8 f! g3 z) Z: O8 g- 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发表:+ P; U% f: `: P. V% R1 e
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。
8 k7 x0 {) L, ?+ e　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
8 S1 d+ K! S! l5 r+ U　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。, M- O) }9 O: @
　　这个是相应的代码例子，基于STM32F103VBT6  j0 Z$ D4 D" P* J, u

2 y. y7 S  w' G3 c1 M4 D0 v' L6 a
: ^% s% C- [( [( `- A# u- a+ u$ K/******************************************************************************
  O' Y7 U, t; H2 W5 _8 ~* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()' C4 T- T( Z- B7 I0 E) N4 j5 t& ~
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输6 g7 v* V4 M4 _$ M
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
" U  Y; V7 ?: B/ e: ^6 }7 J* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART9 F5 a+ o5 @1 e" V& M  N% @
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可
! B5 e1 t  m5 z) h! R* @* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
/ c" `. U9 p* t2 u0 y4 `' J3 m* 串口依然发送，表明DMA传输是一个独立的过程。+ I$ U. n) q4 {2 m1 g7 \& D
* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理  z, C! P- @; g  H7 a# D7 Q
* 作者：jjldc（九九）* w# K  w& u4 s- W8 \, q3 p
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6* d  T; L! M% Q+ u( M1 O) f9 _
*******************************************************************************/" ~6 e8 m9 J( b* O  c

5 n' a6 }1 w7 h% D3 c6 f+ ?+ e/* Includes ------------------------------------------------------------------*/4 y/ W3 Y% R( p% g
#include "stm32f10x_lib.h"9 f! g$ _2 w4 L1 U( V: _+ d
#include "stdio.h"
* R: f, N2 |+ b9 }, P+ ]! p! C0 R1 b$ c
/* Private typedef -----------------------------------------------------------*/; P1 G) h, T% r9 p' W
/* Private define ------------------------------------------------------------*/
) {8 Y: L/ t0 c; R#define USART1_DR_Base 0x40013804
- G  S7 |8 J7 G/ n% \' S& M0 ~/ I+ }# o( k/ m  J: n+ f
/* Private macro -------------------------------------------------------------*/5 {+ j1 d9 }8 i
/* Private variables ---------------------------------------------------------*/! L" v9 G7 e3 O! X8 {* B3 @+ c
#define SENDBUFF_SIZE   10240
) N5 `$ e5 \. h, ]8 o" V4 o+ [vu8 SendBuff[SENDBUFF_SIZE];
# s) Z6 U% E6 D: A: \' Wvu8 RecvBuff[10];) b- |/ X( H! a5 |" V, W8 S' U* k
vu8 recv_ptr;
5 D+ M7 ~/ K: V) q7 G. |0 d$ `" e, x" @; B
/* Private function prototypes -----------------------------------------------*/
5 J. R' m: K7 N2 N) y8 n2 P4 ?void RCC_Configuration(void);
* H  {0 B1 L  k/ Q" Jvoid GPIO_Configuration(void);8 e+ m  ^0 o) D7 G" N) W
void NVIC_Configuration(void);" ?" T2 h% ]) u
void DMA_Configuration(void);6 m: Z1 c8 h4 k4 |) L8 F
void USART1_Configuration(void);1 V% k4 {# L# E- m

  g6 x" c2 b/ p6 ^4 x" H6 gint fputc(int ch, FILE *f);% b0 V' `* C) l
void Delay(void);1 N! T# S' j2 S! w' k* n! R6 U7 p

  U! `& K* y7 \7 D7 o( X/* Private functions ---------------------------------------------------------*/
6 E: i: k* ^, A% _) V7 H/*******************************************************************************
2 ^; U$ o9 d: ^: P* Function Name : main
, t& h( a  _% j+ x4 |* Description    : Main program.# M$ M) f/ i- }% n; N. S+ r
* Input          : None" T* ^9 y2 q7 Q% R+ F2 c/ ?4 U
* Output         : None% L4 \* L$ R6 i2 q( F
* Return         : None
% j% b) }: B6 O*******************************************************************************/
8 E) Z9 D3 A' d' cint main(void)
- n2 B% i# k2 t% P2 C$ Q) {{% ^9 p" m- C4 F. D
    u16 i;% d. X  B* H  o6 S/ T) ^
#ifdef DEBUG3 ?; m+ J: n8 Y, j7 l- t1 B
    debug();
4 X" E$ a1 Y" S, ?& }% R2 k#endif: o, s8 m1 O  Z# Z! A
    recv_ptr = 0;) @8 j) b# D2 v

0 t0 a3 X+ l- {1 n2 u& p    RCC_Configuration();
/ t6 U, k* [" ?' R; V7 z    GPIO_Configuration();
: d! U6 b6 |& p  Y3 o/ M3 q    NVIC_Configuration();
- q& o9 ~; m4 {6 f! q    DMA_Configuration();3 e' G* D3 q& A. C; N  D
    USART1_Configuration();, }1 w+ I6 k+ K8 A& W4 |
    3 d& e3 s5 ]# k1 @$ y5 U
    printf("\r\nSystem Start...\r\n");6 k$ ~: |/ N- U6 y/ a+ K
    printf("Initialling SendBuff... \r\n");
* _8 k* ?8 D- T7 u& s    for(i=0;i    {/ J, }1 v% c) x: P7 m( E. F
        SendBuff = i&0xff;
! d0 N( K. k, R$ R    }. X& u! `. f# d; V0 r" i
    printf("Initial success!\r\nWaiting for transmission...\r\n");
1 k, D$ g, l7 ^# K% X    //发送去数据已经准备好，按下按键即开始传输9 _! Y8 U& n3 D* z! J, b
    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));4 O- P$ L4 c/ ]0 u7 ^* P  b. k

" i8 R0 v5 ]# _    printf("Start DMA transmission!\r\n");. o' x  R8 q! P! c( i+ v1 i. k7 L1 g

* y5 x8 w2 b0 r8 b7 r* p0 z% v( U4 b    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
  d  E0 s# X. Q. T    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
+ v+ H. A, g( Y    //开始一次DMA传输！: E' Z0 ?1 J. H
    DMA_Cmd(DMA1_Channel4, ENABLE);6 i7 ~- h+ R+ p8 h$ ?; v; A6 A

9 ~; ^; }0 \- m' O( O3 C    //等待DMA传输完成，此时我们来做另外一些事，点灯
4 b0 a' g4 I( C6 A    //实际应用中，传输数据期间，可以执行另外的任务; o+ _: X# j: R( ?! y
    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
0 C3 d" _. ]' O- a6 j    {
, G, y+ k4 u+ D8 ]) x        LED_1_REV;      //LED翻转( {+ H9 s5 g5 w) B0 A9 T
        Delay();        //浪费时间
1 |8 v  U( H9 p    }
' b' m: Y% `2 [. T  K7 t4 r, X" _1 s    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
+ _3 ]- \# u/ \$ r    //下面的语句被注释. o, ^3 i  w( r/ t  Y4 r
    //DMA_Cmd(DMA1_Channel4, DISABLE);
8 [0 p' h' p3 q
( A4 W' ~# |8 R    printf("\r\nDMA transmission successful!\r\n");- W% n6 c$ d/ b, Z* B$ M
6 _" s7 @3 E3 ?. Y8 r3 l/ @
    ! }( q0 ]* o, ^0 Q: T1 _+ s. |  P
    /* Infinite loop */  Y$ _6 [+ I) T& F- @
    while (1)0 u2 g8 r: Y8 O' k9 F
    {
. g8 z$ Z# {; m; b. Q    }( U5 ^4 k+ M) @$ t1 U
}
) ?# Y+ G" V4 ~5 r: Q5 S
5 z2 y' [& j; d1 T( ]4 s* f/*******************************************************************************: m5 ~& P2 L+ ~' v9 C3 }
* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
: k  y' t4 l! ^0 \* Description    : 串口发一个字节: _, w' a1 {& p/ U, {2 \4 `2 v9 @
* Input          : int ch, FILE *f
+ f' h/ ]" l8 M( {) m- E2 U* Output         : 2 E) j3 p  H2 i, A
* Return         : int ch* E/ u% X0 z- h( G4 L' o* H( H4 n$ p
* 这个是使用printf的关键5 V1 x( Y0 V. b- s$ t, l/ z' w
*******************************************************************************/
. K; R- T# A" Y1 P" u' Qint fputc(int ch, FILE *f)1 u: [6 S; p' D( o1 b* N7 L, m
{
; Q2 A2 }3 d* o    //USART_SendData(USART1, (u8) ch);
4 ?( j; k( Q. k. o1 G    USART1->DR = (u8) ch;
5 ]9 ]3 E# t5 L3 e5 h% K0 I
& ?3 ~3 T( f+ J# {' |1 \    /* Loop until the end of transmission */8 V3 Y. G) {9 Z5 P
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
* B, ^( F9 _) T( x" K/ r* ^    {8 l- Y7 _" h6 g9 _! a
    }
' c8 Y2 [* P: J  S& O( U; i
! C9 [9 _5 e/ x; j* R& p7 X    return ch;
8 t3 b; ]$ P! j$ t0 y}+ b5 Q4 _' n: Q9 q& V+ P! n
% f1 [5 A8 V! D+ \# F/ y
/*******************************************************************************
+ N2 m, H; b( J8 Q* Function Name : Delay) Q8 `7 x  K- k5 z3 M
* Description    : 延时函数
) ?- T6 `3 h; P/ J0 O* Input          : None2 z$ m6 D4 a( C, a; \
* Output         : None7 R* b, H3 {  }/ o
* Return         : None
/ E" ]$ K9 A6 n4 c4 ?; a*******************************************************************************/
; c7 r, b0 ]$ Z7 i& Vvoid Delay(void); g& V$ e! r- `% x; ?" B4 x
{
+ o2 b" z# ]1 G# [- f' ~5 `" s- X    u32 i;
( e0 o; _3 L7 W  h' \0 U$ i    for(i=0;i外设
- [) s  l1 ?" J& a4 l7 ^$ r    //每次传输位：8bit
0 t7 n8 n! p6 _7 U- s    //传输大小DMA_BufferSize=SENDBUFF_SIZE' n% O/ N' R. V6 n9 G
    //地址自增模式：外设地址不增，内存地址自增1- `. Y" i+ o2 k. A: ]6 {. F
    //DMA模式：一次传输，非循环2 ~2 _0 v3 o/ Y' b
    //优先级：中
) Z  D1 V3 |; F) m1 D    DMA_DeInit(DMA1_Channel4);
: q$ P1 l9 X) e& r+ t& v    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;# I$ b  H6 K3 d& J$ e. ~
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
9 C$ X: a4 n/ G    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
( }( |" V7 N+ X% V8 U% f2 v    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;/ E+ Z) ?* f. q5 V0 \$ ~( e
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;0 R; W2 Q, W, h! U( M( K
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;# {- R# Y  `: u+ T/ ~
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;2 B" G/ v: u2 A* M7 X
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;1 j0 t7 j3 w% S8 K
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
. @0 @8 n* r7 [  e( J( p5 q    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
. o: r* O5 Q! L, N( Q    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
2 G& {$ T5 e, e; `% Q    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
& B5 ?& f! m3 \. T! V. M}