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;0 {' U- b: Q# |. t' v/ y) X
}
7 M/ O& ]$ U1 ]+ p$ e printf("Initial success!\r\nWaiting for transmission...\r\n");1 a- M% Y0 |' S* M9 _% F+ b
//发送去数据已经准备好，按下按键即开始传输
4 y7 B2 Y3 I! L& h5 x2 K while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
5 I" Z, f3 o0 A& [+ c' I. k
$ `& j/ _) {" i( A1 f printf("Start DMA transmission!\r\n");4 m+ y2 L# ^9 d- p0 i3 K! ~8 A

( X: `! ?2 |' u- I4 p //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
) }5 A' p! t& f8 x  D5 d+ T USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
! p7 k" H, P. ]) L* _ //开始一次DMA传输！) I3 B* J* _. ?5 @0 q$ l0 ?
DMA_Cmd(DMA1_Channel4, ENABLE);0 D$ ^1 x9 d$ v) d. ?4 |, P, U+ M

! S5 E8 x4 d- t+ C# V8 W8 y6 ` //等待DMA传输完成，此时我们来做另外一些事，点灯! F, q+ C3 \, ?6 i7 ?
//实际应用中，传输数据期间，可以执行另外的任务
, g- D5 Q% g5 u$ s5 b; o  C; e# t) j while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
4 S, I, v- \4 [" D* U+ c" }1 [# A {8 ]3 O1 t4 c4 Z; v! j
      LED_1_REV;    //LED翻转) q5 H( b5 @( O9 I# v1 `7 ]! r
      Delay();       //浪费时间
2 J! n2 p) h% }$ K& W }* A) B6 W2 Y. P( x
//DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
) p, d; d! N1 y. B) i* n" }  D- Q //下面的语句被注释
( f4 V$ G1 z1 \# q' ]7 H //DMA_Cmd(DMA1_Channel4, DISABLE);* d3 Y8 M1 l6 D+ I& Y' O

- ]! r, S% ^, @ printf("\r\nDMA transmission successful!\r\n");
3 M) I" q! c% z: q8 k- o4 B% ?
8 G/ b+ l2 T% s' Q6 a ! `7 c6 m; R# G1 Q5 H
/* Infinite loop */
' O7 N- g$ S) `  g8 C. Z" a while (1)
' i  ?( J0 e8 w, J: N! h/ [) G) | {
" {* i- X7 w/ v7 p }
2 B! ?7 i& ^; E! ~/ ?3 J  `}
- r$ h0 K! l, r- K5 s: T# J7 I- p/ n
/*******************************************************************************
+ [  K1 G# r# _* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)
5 T5 ]$ O: D; L+ o* Description : 串口发一个字节  K7 k9 K1 A; L6 e
* Input       : int ch, FILE *f2 \( c, F  [8 `( [
* Output       : $ R$ }! ~/ V# L+ R& \" ?% ]* X+ L& u
* Return       : int ch7 y% y7 \# J. Q! T9 z
* 这个是使用printf的关键
8 S3 a/ [0 J1 u0 Y8 E5 e*******************************************************************************/- }( P6 V/ q+ R
int fputc(int ch, FILE *f)5 _1 k4 U% F0 _3 T2 r0 I
{
' e8 Y6 E* |# `* n //USART_SendData(USART1, (u8) ch);% x* u) D6 U& j. c
USART1->DR = (u8) ch;1 L. J) @% _4 y- c0 Z

0 ^0 |7 X! I# J9 s. N /* Loop until the end of transmission */
, d5 Y3 k5 A% D" X6 ~ while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
. R7 D% s" ?) X, X4 N# a! d$ n {
3 k5 i# M  u8 b# { }: Z- g+ M% v8 l# M. o1 A
' [$ R! ], z7 C0 P
return ch;
' q$ b4 W; ?/ N2 o9 q) e2 O8 q}
8 e* M7 P$ M% ?" L2 M4 W
, n: L; O: Z0 i0 b/*******************************************************************************, @" q9 ~2 K" T
* Function Name  : Delay3 s9 }) m8 U  d& w
* Description : 延时函数
( C3 F0 N+ g/ C) U& C) G* Input       : None
9 b7 _+ s: Q7 y5 _9 c* Output       : None6 n2 N/ q5 m$ m
* Return       : None
6 E1 I/ Z+ W% S*******************************************************************************/
* ~, z; v" M4 _3 u) wvoid Delay(void). A6 k- z7 m3 f
{. i% j1 z+ v+ b8 }5 Y  P/ n1 U
u32 i;
1 ^6 n2 U# ]. p' G2 G1 l5 A- z for(i=0;i外设
0 T" x+ m9 E! f+ L7 g% [ //每次传输位：8bit2 n, I: E3 `7 U9 E- C& x
//传输大小DMA_BufferSize=SENDBUFF_SIZE9 P+ |- Z9 p: ?' x3 Z
//地址自增模式：外设地址不增，内存地址自增1: s/ r! _! a" ]. K) @
//DMA模式：一次传输，非循环
! s. w% a7 R: s6 r! S$ P* s$ J //优先级：中  L/ a: x- `7 Q: n
DMA_DeInit(DMA1_Channel4);
) Y4 E( s0 g) N/ J. Q" s: j DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
, I- W& h8 K6 F DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;. ~$ z1 f4 @8 E* g# Z
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;( `. d3 [0 l2 o
DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;& R; H% @9 ?- [; h, N
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
( y! l/ f: V) o0 N* q DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
. l2 _! p! K/ U- O DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;" o6 b1 m+ W$ B) C( Q% {
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;0 B' k0 e* P' Z) v8 `
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;/ L7 M" M8 V3 ?# _7 g
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;+ d# e) `, O9 C$ x* N
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
; V' T, ?" b- u DMA_Init(DMA1_Channel4, &DMA_InitStructure);+ C0 h% L2 x1 W7 U; r7 _# U2 d
}

赞收藏评论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发表:0 C2 Y; L6 u( L9 c$ `" A6 b
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。1 G9 |* I5 Q  J  t! u& M/ L7 P/ _
　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
  t' A6 f+ |, R2 F$ l' r# p　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。7 Y8 c; @* T* c$ P" b
　　这个是相应的代码例子，基于STM32F103VBT6' n( i9 T7 k6 S: P0 y7 @
! o9 J6 W/ ~0 [; _" q

0 W5 T' H6 T, c/ K& U/******************************************************************************* V& ]$ c4 _4 O; o
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()
  }2 n" Q1 g3 J* I* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输) _7 ^* Q  L+ G( Q+ F8 g8 t5 O
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，4 D. }; z( v: A: R7 o
* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART
2 B7 m" x2 `) V1 t* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可$ Z, v* z) e0 @4 Y" A/ V$ e
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止! [+ l, z. O- u9 U. k9 Y/ l
* 串口依然发送，表明DMA传输是一个独立的过程。
+ D2 J% v3 x& ^9 H* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理" s! y6 j1 c3 z/ v9 s4 R
* 作者：jjldc（九九）
" K" o5 d- b9 x' S- j( s* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6
, t* j/ K) u* V8 a: @*******************************************************************************/8 ~! s; {5 C6 x, Y; l% C
/ M5 T( L; ?' J6 u( C. Q$ g
/* Includes ------------------------------------------------------------------*/8 m+ W9 l8 e- ^, @- K+ J2 d
#include "stm32f10x_lib.h"
- h6 e* T1 a- o* Z' T2 {#include "stdio.h"2 b3 A5 }: V; |
  J+ G1 p' x9 I& ?
/* Private typedef -----------------------------------------------------------*/
) i% l2 f; }  }( I5 _/* Private define ------------------------------------------------------------*/
0 G& j9 d4 E! y2 _! C2 M5 O2 n#define USART1_DR_Base 0x40013804: H9 a8 D& C- c; G+ g# t7 f

* x" T0 k$ B; x  Z/* Private macro -------------------------------------------------------------*/
4 T8 z9 A7 H: v5 W/* Private variables ---------------------------------------------------------*// m" n) Q7 d( I
#define SENDBUFF_SIZE   10240" c6 L) Y9 ]! _2 `3 o
vu8 SendBuff[SENDBUFF_SIZE];; t0 L# w# H0 I$ E' L6 t
vu8 RecvBuff[10];
2 ^. ]" Y& o/ O' |/ Fvu8 recv_ptr;
' U% Y0 g! F1 o  }
/* Private function prototypes -----------------------------------------------*/
' }/ D3 g: u( R% svoid RCC_Configuration(void);0 F9 B% @9 F& o% b
void GPIO_Configuration(void);
8 o% k: b0 L( ovoid NVIC_Configuration(void);6 x' P; h. \5 a, t+ e/ W! a1 g
void DMA_Configuration(void);+ _/ \3 J0 j+ R* M# m
void USART1_Configuration(void);
: n- X  E, r# m; [* M) S( L6 W. y  r4 s
int fputc(int ch, FILE *f);$ n" w1 X$ L. b+ d
void Delay(void);
) b8 Z0 j- s: \9 O: [. A5 z
' k8 f# p, i- {! D8 V/* Private functions ---------------------------------------------------------*/
) y2 Y8 m9 I6 I& k" I/*******************************************************************************
: [) b% C* e: p1 A1 n* Function Name : main
' i3 N& c- m" K# l1 ^" C* Description    : Main program.
1 _6 C" P" b* V! \* Input          : None5 S" i! C' e3 P
* Output         : None
6 O; H6 [# P( H  c% J+ M* Return         : None$ u( K3 T- m) a9 y9 l5 H
*******************************************************************************/
) V9 b/ F" C( oint main(void)
5 R6 A3 p9 O! U) V+ g, z{
+ ?6 O0 `* l; C& C/ q. w, N    u16 i;2 b: z1 H, I2 F- h+ A7 [0 ]
#ifdef DEBUG* H: k6 x* E- y6 N# |2 D
    debug();
$ J! i! M6 d& a1 Q; Y) x2 {$ l#endif( |4 c$ U: y2 b" p! `
    recv_ptr = 0;
* [8 R) V: t( m3 b' F
" ^  E" n" z- w" _3 [8 Z. k    RCC_Configuration();
  @. J* r5 X" q! r- l( @) R" J    GPIO_Configuration();) P0 @( l) s$ O$ n. k
    NVIC_Configuration();
1 }. B3 L( Y6 z# i- B    DMA_Configuration();
( T! J; j2 d1 D    USART1_Configuration();
6 M) C9 v- v! k' f2 ]) k2 e' s    & h1 ~. H, ~: R
    printf("\r\nSystem Start...\r\n");% v+ g) t  D- F" s( A
    printf("Initialling SendBuff... \r\n");  H7 O' T. d; G
    for(i=0;i    {
' |, Y! u0 v3 t7 Y, o/ a        SendBuff = i&0xff;2 @! c' {, Q/ c% R! D
    }# U, s+ G( h. p' W/ `' `& K
    printf("Initial success!\r\nWaiting for transmission...\r\n");5 B  ^) \" o& Y* \5 {; ]. P  F6 w: B
    //发送去数据已经准备好，按下按键即开始传输5 M1 W- G  A* A" q# `
    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));+ }2 X/ n' j' l: n( m
    2 t, s4 Z5 o" H/ a2 L9 l; O1 U8 a
    printf("Start DMA transmission!\r\n");
8 A, W$ M/ ^  `    8 T# d) _  {6 x8 f* T
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
, J) V) `9 E8 G2 v. F9 D' H' i    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);0 f; o  J* r( d& E6 B
    //开始一次DMA传输！
  ~& m4 ~* k" `, r9 f1 A/ H    DMA_Cmd(DMA1_Channel4, ENABLE);/ S. L( u1 ]! A  p

2 v9 J3 J0 T- c* i. t( l0 T    //等待DMA传输完成，此时我们来做另外一些事，点灯! ]6 p7 R  Q+ B7 X. L7 z& x
    //实际应用中，传输数据期间，可以执行另外的任务
$ r" W' K/ Y8 f! d    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET). F, m6 I" O' k1 a( C1 [/ }: h5 ~
    {3 c/ g8 O. o# r9 V/ }9 A( p. D
        LED_1_REV;      //LED翻转
) ]6 T( h2 Q5 h2 W5 h4 o: V        Delay();        //浪费时间8 @8 }; U+ K0 P( M  K' l
    }! z2 ^6 v# ~2 Q- b* o
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
( y5 I: P$ w! {  h; c1 {* B' o    //下面的语句被注释5 M  Z/ j0 q5 b, ?4 ^/ L, c
    //DMA_Cmd(DMA1_Channel4, DISABLE);
2 k" m/ ~8 n7 B    5 b# K; B/ t5 F2 `7 ^: U- _- g7 ~
    printf("\r\nDMA transmission successful!\r\n");% ]& h) W* D7 K+ m
8 n5 o& ?0 b) k+ s( t8 e* T

. u9 k; w  y8 {! G    /* Infinite loop */
$ N8 ^) r. S) F' ^    while (1)
. g4 N$ R' a3 h+ N    {8 q+ S" W0 |5 v" i6 i6 U: R
    }# e; ~+ r% W  }$ A) E% a5 B: z
}
7 ~' B6 h& n1 y( v
! X* t5 Q7 l9 }. R" z/ q/*******************************************************************************: @% S, a, b" q
* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)* ~/ v7 N5 S5 s
* Description    : 串口发一个字节0 f" v  Y$ j  W
* Input          : int ch, FILE *f
& e6 v5 j3 O- V8 O0 x& Q! v* Output         :
, e, p0 [1 l& F* Return         : int ch- `( A) P* x* b5 A5 o; q, x& J
* 这个是使用printf的关键
& R* e+ z! W8 k9 R' C' J% S. Z*******************************************************************************/: V* h1 ?- ~. {0 M
int fputc(int ch, FILE *f)8 r; X( I+ ]; b! u, b
{( e5 G3 z0 y& S" E' J5 `9 W
    //USART_SendData(USART1, (u8) ch);# w4 m9 p8 ]. P0 a  A! L
    USART1->DR = (u8) ch;. w" [+ k. V9 A" C

& o5 e* r  d, a8 p1 ?% v0 l4 N    /* Loop until the end of transmission */
, l+ a7 ^7 B& N- C8 c# J: r    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
) |, |$ U; @% m9 Q# @    {
8 P; k4 I- T" ]* e) C% D% y    }- ?; z5 I. J  j3 P
5 z7 t9 g+ S! v3 L2 d
    return ch;4 K4 Z1 O" I* \- Y5 D7 Z& ?
}
# B1 Q, |  t/ K* d1 u4 u4 T, E- r1 ~; [
/*******************************************************************************5 s$ n  W7 C1 K, R: Y  I
* Function Name : Delay% i/ F7 r# ]; x8 `+ V+ `
* Description    : 延时函数
/ S4 x( l3 \5 x$ U( o! Y* Input          : None
0 x, v6 m6 M* C: l9 T* Output         : None4 Q7 y: X2 d  B/ d. i; Q
* Return         : None0 M* J' D, e! c6 e1 ^/ e! z
*******************************************************************************/& s) w+ e6 J$ X# I9 G) M6 {+ P% r# ?: v
void Delay(void)1 a/ v  G- X, T/ D
{
9 i) N! q% N9 W2 A    u32 i;& [& x" P, ]- s! b% m
    for(i=0;i外设8 I% V* W9 s+ t- Y
    //每次传输位：8bit2 e$ _4 m6 q0 ~: C+ ?, w2 ^8 F! O
    //传输大小DMA_BufferSize=SENDBUFF_SIZE
$ ]$ a, q8 @+ t/ q    //地址自增模式：外设地址不增，内存地址自增1
7 a- `* l4 r- Q8 |- D/ c5 T    //DMA模式：一次传输，非循环" u, R4 x- W- N% [# @" n4 B
    //优先级：中
) {$ x2 L- W5 N4 V& |' B    DMA_DeInit(DMA1_Channel4);5 `. E, j: ?! C) S; }  e2 o5 W
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;1 ]$ q1 r; A" r5 p
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;" d  K/ J, i. K: |
    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
/ K1 l0 I9 i0 F' `( u2 ?    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;/ J4 ^% `- M- s2 `7 e) R
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
0 A& ~0 f  D4 o+ F1 g( H    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;" W! s3 `0 a+ v& o
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
9 z' D2 J2 K* K& k    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
. J1 K# c; s8 c  p    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;8 c- c1 ?" i; E% N# a8 {0 Z# `
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
# ~9 c3 r+ d- g3 B. F    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;( Y: i( w, x# A/ }+ m, a
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);
% G2 r, q  G" T' P# @}