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;* @3 w/ `8 L: b, r
}
- \; Z2 V1 o/ t, l printf("Initial success!\r\nWaiting for transmission...\r\n");
- g. }/ A& p1 f0 t# X7 T8 N; Q //发送去数据已经准备好，按下按键即开始传输
* T0 g3 B' _3 x; Y0 } while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
! y2 G( D; U* e+ Y* e) k
* n! ?/ V1 m8 R. U printf("Start DMA transmission!\r\n");
  {5 H- U" l2 S( i& e+ s. L
; Y2 u+ V. f0 I1 S% h //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
* G# M% q# m% k' K- w, { USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
6 u" ?6 L6 ]. g //开始一次DMA传输！+ v/ F! u6 Q2 N- V1 K
DMA_Cmd(DMA1_Channel4, ENABLE);
. K& j% A2 D6 Z+ B  |9 @
. i. w$ K8 e/ G1 A, ~& j4 { //等待DMA传输完成，此时我们来做另外一些事，点灯; n! i% [" [( E9 U
//实际应用中，传输数据期间，可以执行另外的任务$ s" ^* g9 h& J% Q7 l" a8 B; k
while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET); @1 N  [% R  a( W; v# Y" U
{# W3 L9 b& q9 j; s. ~
      LED_1_REV;    //LED翻转
9 G( `. {/ c# A( H6 V       Delay();       //浪费时间# ^8 n( I3 Z, d+ k
}) K/ i' J8 \8 u
//DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
9 ?" T8 s' m$ \) m5 s7 a6 y: }$ D //下面的语句被注释! `  ]6 E0 w$ X1 \+ a
//DMA_Cmd(DMA1_Channel4, DISABLE);! i5 w8 I2 y& n9 F% x
/ J' r* i% c% X2 f
printf("\r\nDMA transmission successful!\r\n");
8 K& [0 u5 T# _' p# C
& l" F' E3 b* o1 u6 U. t   C: w9 H/ b3 u7 k# c" G" i/ A
/* Infinite loop */( x  h. }# \  D
while (1)5 Z% h. Y. q' c
{
+ m0 a6 C" ]5 D& g) E  G }
" `4 V, J+ i* x4 A% D. }}
% W$ M# e+ C4 M; K2 i0 O7 j5 X  i1 Q2 M6 B$ y7 z" o% c3 I+ D1 u
/*******************************************************************************. G: b: b' @0 H% Z+ C
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)5 W, a, s+ B8 @+ y: R/ A. R& u
* Description : 串口发一个字节
) V. o/ q7 l2 C; R' F6 W) y; V* Input       : int ch, FILE *f
( c4 f, @, ^9 m* Output       : % z. p4 f3 j+ j0 M4 d" u
* Return       : int ch
0 ^" B6 S4 @3 R0 T& {5 v* 这个是使用printf的关键) }" Z0 N, ~6 U  p, Q
*******************************************************************************/
; S3 {2 a0 Y" {8 Sint fputc(int ch, FILE *f)
: U8 s& v7 i" C1 e* R. E! N  d{
+ s% r/ v  ^$ o$ D //USART_SendData(USART1, (u8) ch);2 {# |8 @' z9 S8 d, ^
USART1->DR = (u8) ch;6 D3 S3 W' X, w
' v. @! i! k5 n
/* Loop until the end of transmission */) p- K2 X9 r- t' V0 U7 T
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
4 v, T. Q0 A* u  e$ v; w  j {
% C" l! ^! M- h" H( Q( b! M }
. `  q/ N1 g- r9 S
- j" Q& v' m4 Z' t, m4 Y% } return ch;9 _' Q- h; _# f/ `3 [3 @8 Q
}
' w) L2 c# ]( M/ C7 g" |
8 J. r0 m0 X; g/*******************************************************************************+ z  C0 ?' G0 S, r3 z) j
* Function Name  : Delay& D: b3 z  r: r
* Description : 延时函数$ H9 [' z+ j# ]6 O, W$ L
* Input       : None3 p: Y& x! ^# m4 h; y
* Output       : None
. j$ M) J. {5 c/ a$ ^* Return       : None
- ^( _# l" {" z% p# V*******************************************************************************/
void Delay(void)
& u6 s! N7 M; T* {- u1 O{
7 l7 \+ r; Z1 v0 ~) G u32 i;
; [) `- S, v7 O' B* {( L( P1 D$ ` for(i=0;i外设
2 c3 w$ `# }/ i/ R- `1 V  N //每次传输位：8bit
' o4 |( T5 f: @3 \ //传输大小DMA_BufferSize=SENDBUFF_SIZE9 ?6 {- H0 C4 N: q- H$ I# B; i! Y
//地址自增模式：外设地址不增，内存地址自增1
" W) `! g! ?8 c+ P2 r6 } //DMA模式：一次传输，非循环& s* h) H# D3 @% ?" [7 p" H6 w/ C  h
//优先级：中* S9 |# n$ z+ i$ [0 E
DMA_DeInit(DMA1_Channel4);
6 [3 B: C1 f9 \: s. n5 I8 ?4 | DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
1 V3 o# [/ B9 \9 \  e DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;3 F- d: H5 b6 i, L5 }; p! A, D
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;- e5 k1 d/ E+ {% O- t
DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
$ x  ?9 h0 R! A  H1 U) g DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
) P: s5 ]  r) [5 r2 T DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
6 }- O3 h/ [8 W+ T# u0 v% r DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
( a/ P1 d4 ?0 e2 [ DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;. A, |5 K, X- E7 G1 ?
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;7 b8 G2 W5 G2 H! b! Q
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
: f- H3 |! r0 K( w# o: I DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;3 X: j6 l0 I: S& t' g& |/ ~
DMA_Init(DMA1_Channel4, &DMA_InitStructure);$ t  i2 W) W4 {9 E" r! x
}

赞收藏评论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发表:/ M: v8 ^( ^3 l
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。
7 [  N8 d6 \- F( z( A; a　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。; C4 q6 I9 a0 n, J2 \% A
　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
3 n5 q+ V2 S% P/ y$ |　　这个是相应的代码例子，基于STM32F103VBT6" |  t& h2 h* r# S- o. Z! R
* ?/ L$ _# T" U9 {: C2 G
9 ~$ [* }& h! O: \. ]% w, o2 z
/******************************************************************************
5 R; S' `/ t$ ^$ p6 _& ]1 G* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()
4 m- ^' I! j* c, F- z1 Z, z, H* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输4 S* d4 t- u8 h/ t' |9 x" _/ J, p8 H
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，4 ], i0 p" z$ w$ D
* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART( i- u- H" P5 Q7 t6 C
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可
0 U! M9 Z. C3 N. J2 ~; R* `+ D* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
& ?$ F7 G& F- `5 h* 串口依然发送，表明DMA传输是一个独立的过程。9 j9 r% a6 R- u# H; F; H- L2 D
* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理
6 U0 b+ b. q1 e2 u$ [* 作者：jjldc（九九）1 Z, o/ F8 l+ h! f2 L
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT69 `1 N  _6 e6 {$ f6 h' `4 ^9 X
*******************************************************************************/
* s* a( _3 s0 i) `: u
$ J! Y  q6 j+ k- T* c" S  ?7 j/* Includes ------------------------------------------------------------------*/; X8 D. e, f3 d, \& |4 d( y- x
#include "stm32f10x_lib.h"
& m2 n, }4 L- Y" q" [#include "stdio.h", a5 K& h! b9 P0 x( _0 Q
4 B$ Q- G$ G( c0 Z
/* Private typedef -----------------------------------------------------------*/$ T. c8 a; f( \/ f$ [
/* Private define ------------------------------------------------------------*/
# N2 c# D) o9 E. l6 @$ {1 C2 x#define USART1_DR_Base 0x40013804' ~" t' l! i; W9 f7 a. a7 p2 a

/ S9 \; ^9 ?" {9 M, Y+ d/* Private macro -------------------------------------------------------------*/+ b! s* S5 P5 I5 B0 V7 r
/* Private variables ---------------------------------------------------------*/2 l; b5 y9 y) }) ?8 J% N
#define SENDBUFF_SIZE   10240, m6 ~% H8 `( c2 ~) \6 z
vu8 SendBuff[SENDBUFF_SIZE];
8 Q& a6 E3 T+ b, V3 b" x1 c1 }vu8 RecvBuff[10];
( o7 q0 |. I& O! O0 W, h/ svu8 recv_ptr;9 a; u7 Y# s$ G8 }. y) z. i
  q5 ?# y5 a3 Z+ \0 G% Y
/* Private function prototypes -----------------------------------------------*/% k) R  g; a' p$ G5 u
void RCC_Configuration(void);
! Z. Z2 T! ]9 t2 S. Tvoid GPIO_Configuration(void);
% N; s" }1 ?; o# E  i/ Pvoid NVIC_Configuration(void);) W1 b: b6 k) l, K5 S2 T
void DMA_Configuration(void);
: u- O+ b2 c8 ?7 P, \1 gvoid USART1_Configuration(void);
6 S! |: A! {. {; W4 Y7 P# W3 s9 H; f6 l
int fputc(int ch, FILE *f);. T9 P. @& H6 L  p
void Delay(void);$ V/ m! @; V' W
9 o. b4 h0 H* [+ h  b6 h9 ?
/* Private functions ---------------------------------------------------------*/5 y9 h, [, A0 P, U" V+ z7 ]
/*******************************************************************************  R/ F6 Q0 X! n8 p, [; v! J, o8 \
* Function Name : main2 |$ s. x- _1 ?2 Q# C& t7 @' w
* Description    : Main program.
* L5 y" ~4 x' Y& n7 }* Input          : None) j/ L+ G6 M  d& W. w" h: ]& G
* Output         : None
% L0 I" b. }/ q9 \8 K& j* Return         : None
6 B& E  _2 R# u' L*******************************************************************************/; v. t, X; r* j: W& C7 o
int main(void)
" _. h! p& L" ^8 s' x% D4 g{( `! k3 L$ [" r
    u16 i;. w; B" K2 o4 G( d! d9 R; d0 k/ I) _
#ifdef DEBUG
" D0 b" @$ o4 ^1 A$ a) J2 _; p9 g$ G    debug();/ T& S: J' E% v  Y# V9 C$ X
#endif
3 h& X, C: u  _; {% J' y, o    recv_ptr = 0;0 v2 S& ~' U( l) I

' Q$ Q  J/ O* r3 U2 q0 I$ b    RCC_Configuration();# O/ S, \3 _6 r) x7 q
    GPIO_Configuration();: x# F* H: A' O7 o, l, t* l
    NVIC_Configuration();9 ]! B1 b% }0 |- r- @5 o. P# t' n
    DMA_Configuration();( G6 ?9 |* Y$ A/ c* I
    USART1_Configuration();9 m! ^$ v$ _* [0 [
    - w& W" W6 b: D5 C) F
    printf("\r\nSystem Start...\r\n");
) r  ]5 X1 [% t    printf("Initialling SendBuff... \r\n");: U+ t2 _$ w. C! j$ v# P5 p# C2 E
    for(i=0;i    {
) ^# S- B) l# O2 y: x& C        SendBuff = i&0xff;7 g; }6 I' C  t6 H9 g& d# `( ~
    }5 r0 Z( [6 y* o2 O1 B. ?9 f6 Z
    printf("Initial success!\r\nWaiting for transmission...\r\n");
  x3 X5 c/ l1 F. j2 S    //发送去数据已经准备好，按下按键即开始传输' _1 C8 A8 _3 I' m2 M
    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
% ^1 o, H) e  A+ n! [5 x! |
, U  ~. Q) ]* H2 L    printf("Start DMA transmission!\r\n");
- a  k/ `3 g& }* C4 W    8 w  ?0 r- M5 E9 I
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作8 Q" _0 r3 k" |, A
    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
9 P( C' i: i- }& \6 F! T    //开始一次DMA传输！
8 n% t+ Q- l8 m    DMA_Cmd(DMA1_Channel4, ENABLE);
- t- `* Y$ S9 D. K8 V- w    3 A. l  O7 j9 k, T8 _- v/ J
    //等待DMA传输完成，此时我们来做另外一些事，点灯
) d9 A; t& C+ H$ b0 Z    //实际应用中，传输数据期间，可以执行另外的任务
9 y1 h  S' B5 c: S7 M8 ]: D    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
  U' G, f" x# a$ O    {" g$ T" r7 A- e' u) k
        LED_1_REV;      //LED翻转  d8 {* p8 |2 w9 o7 d7 \
        Delay();        //浪费时间+ y, d" p1 d, f8 {
    }
$ ~" L* Z1 s8 s    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
0 u+ \+ D' [4 P$ D0 @: n# X    //下面的语句被注释* q9 N6 {; U3 U- @" m
    //DMA_Cmd(DMA1_Channel4, DISABLE);: o! P6 A1 z% g8 d

" l3 o8 c; m: X& |" c) B( U) \    printf("\r\nDMA transmission successful!\r\n");3 s' I  |$ P; G& X! u. P
& l0 ]0 v2 C: e+ X: P: K+ Y

" z. o2 a& s6 Y5 L0 J    /* Infinite loop */2 _! C+ N. {; I% K; i: p- c
    while (1)
' M) @0 n& ?6 {9 Y2 h% e/ T! N    {
# Q# q: t. S  }0 L* p8 L    }
3 C& X2 {* f/ n- k}
3 o- C  Q- G* x- i- M8 |+ l/ g1 K# c9 j% L* B5 p: |
/*******************************************************************************
4 K; i. G7 Y! I6 Q+ o* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
) i3 K9 e/ V% v6 x/ N* Description    : 串口发一个字节
: d% {; J( [7 R& b. f2 n* Input          : int ch, FILE *f+ {% ~3 d8 z, [3 Q: H  P# F- m
* Output         : 4 T$ O3 f, B# a" R
* Return         : int ch, {6 S( q) y; f" l5 a! A8 ~2 w2 T" }
* 这个是使用printf的关键
+ e( M, [/ n8 |! Q2 F% x*******************************************************************************/
. p, w- r/ J- v# j+ d* yint fputc(int ch, FILE *f)" l. C9 B" q  K5 }1 X
{
  h- h4 M* V; l# n; n, v  K* V    //USART_SendData(USART1, (u8) ch);3 M7 C! v# y! K
    USART1->DR = (u8) ch;
9 Y& Q! y( P5 F) L
  O* s: H- d& v    /* Loop until the end of transmission */& v+ Q. d$ e- Z9 H) v$ ^+ y
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
/ E& _; ^6 ^# B% Z    {
+ h+ Z: M5 c& B5 ^# }    }  s9 z$ k4 h0 B7 Z

$ B; J' n9 P5 v$ l    return ch;1 J  r" P2 ]$ |$ F
}
) ?& T# B3 g& w8 z5 a! W
! p1 R* \6 S/ D0 y' b/*******************************************************************************
! z- k, Q" p, z5 c$ S* Function Name : Delay
/ q9 \: x$ `' u$ O4 T7 x* Description    : 延时函数
9 y6 K" U) N/ H% l# n7 g8 w1 i* Input          : None
$ z. Q  Q8 r  ^- @) }) w: [* Output         : None
6 C" N# m: e0 @: ~& t* Return         : None; l( k- ^$ d$ A1 H$ ?' p% i. Q
*******************************************************************************/* `* d* x. R+ o  N  E
void Delay(void)4 D6 N) I9 r+ {7 s  `
{2 D/ F" M& r5 u$ N/ G/ h
    u32 i;
9 Z/ X6 P& j3 B# ^+ n3 i' X7 h    for(i=0;i外设
* S- Q# B! [; A) l$ H' Q    //每次传输位：8bit
) p( i* Y, [9 q3 n. E7 w0 O    //传输大小DMA_BufferSize=SENDBUFF_SIZE( |- d5 s# }( {0 t" O) D1 r
    //地址自增模式：外设地址不增，内存地址自增1
' t& z6 {' T# N8 W2 Y: r- L    //DMA模式：一次传输，非循环" }9 Y* J( Z+ @# b* V/ g3 k
    //优先级：中
  f3 ^& f- d$ T) ^% `    DMA_DeInit(DMA1_Channel4);# k# A! g! }- [8 i% }8 |! l
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
& c& r- ]8 m8 o$ x/ ]3 i; N0 }    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
! U" o# N. b6 i5 s5 J# t9 z    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;  R, I) k! ~" q- e
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;' d9 {6 B" b+ e+ P: W
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;7 D( M8 g% h' `6 L! D$ g
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;# q. o7 m$ ~- ?9 i8 M& S1 G- j3 z
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
9 P3 L, w9 u% I9 Y: u* v. ?* m    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;0 q1 ]0 t& c; S; u0 V" h; \
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;) U' D# Q, o7 k7 b# l8 p
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;! S  D+ ]6 _/ k( {4 e3 q) X. e5 p
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
5 k. k$ Q8 P- u2 M' |; G    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
8 L. ^) T2 U" k}