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;5 i& q0 }8 Y4 N
}! }* Y% x* C" g) q4 B
printf("Initial success!\r\nWaiting for transmission...\r\n");
' d( u3 h; v4 K& j0 ^$ `) Z) `% Y0 T //发送去数据已经准备好，按下按键即开始传输/ h1 p- q: O2 E) `1 ?: w8 F
while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
4 A7 Q3 _& {& V3 V% l4 D
$ ^9 `$ V1 P. X& o printf("Start DMA transmission!\r\n");4 M7 H' J4 m6 i

9 G7 d/ A6 ~1 ^ //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作$ Z9 ?' a' S: U% I
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
* _$ U' [" E& ?* X //开始一次DMA传输！: G8 v& C  e% E5 d3 V
DMA_Cmd(DMA1_Channel4, ENABLE);5 S' N: K" d$ o- }6 K" ~

# U2 ~3 ?, r* Q6 D9 g5 I //等待DMA传输完成，此时我们来做另外一些事，点灯+ d4 X% ], u9 D" q, D( l  `# |! p
//实际应用中，传输数据期间，可以执行另外的任务
$ o( W: g( P) J8 C3 [ while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
5 J& q2 F. F0 Y {% |; x- h) L9 d/ T! i: `* M7 E
      LED_1_REV;    //LED翻转
* r9 t5 a& G( ]9 k1 Y& u. {6 ]' K       Delay();       //浪费时间7 s: \& l3 r  n
}
7 Y  l: N! b4 ?1 V7 \2 Q- O6 Z //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭4 w5 T- A+ Y3 I$ H( D! P! n6 S# s
//下面的语句被注释/ H( H" H& W% c# x  B6 |$ @
//DMA_Cmd(DMA1_Channel4, DISABLE);: T: D% r2 c! o% Z6 `! c* t3 _

# j; }) S% [' }( H printf("\r\nDMA transmission successful!\r\n");8 P4 g* i; y$ [' I9 e* \/ i3 R4 [

( ?, V. N9 m3 q. ]2 B" D
" N7 A+ `+ r3 ?4 [# J /* Infinite loop */
1 i. O. ~( c/ `/ S7 F3 Q while (1)
+ ~! j/ k' D& M! L" R {6 t& z9 L* ^+ a. Z2 P8 ?
}
! T: e8 M( z3 B}7 `" Y; M  h2 i* S

) \+ D3 T; G9 j5 ]; d/*******************************************************************************/ d- c+ G6 H) \" D7 k
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)+ A% _$ z( _' m& [6 s7 n3 j
* Description : 串口发一个字节
; d6 P6 S( @& K, b( y  ]* Input       : int ch, FILE *f
* @+ F+ b' {6 [4 L  k# z3 }4 J* Output       : $ K; v) I' ^; C* a* ?5 x
* Return       : int ch+ A; f6 S! y. ^% I$ H+ \3 @1 _  X0 z4 H
* 这个是使用printf的关键7 P" i9 k0 K0 v
*******************************************************************************/! O/ |6 |* f0 U7 k
int fputc(int ch, FILE *f)
9 v' ?( T" u) r- D. ^2 K5 L1 M{
1 F: o! I8 G  u8 w( ?$ u" M( l //USART_SendData(USART1, (u8) ch);
+ t. a( k3 {' H USART1->DR = (u8) ch;
& E5 h, O1 w+ C% M6 c8 }5 d5 E4 v
7 z* Y- P. o2 Q8 ]% W9 `; ^2 m /* Loop until the end of transmission */
% [8 q3 q2 B0 T/ T while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET). ?; ~/ o& d6 X) ~, {
{3 B* i4 `7 L. c( L3 c0 d! O
}5 T, I0 z* e: G8 K
/ j4 N7 L0 e2 q5 a5 I
return ch;
) J0 D' a" l0 R: _$ |}

/ h( `. Z& B0 Y* l7 y' t' y! y8 O/*******************************************************************************7 `* O: D" z* ~2 i/ e1 c2 t. A
* Function Name  : Delay
% ^* P. [4 v" ]) m" B* Description : 延时函数
# H' u- \. r( E2 M6 C- _* Input       : None
. q9 x5 e' y) l8 ^! \* Output       : None
4 d( U5 J" w8 \1 a* Return       : None
& L0 P4 M& F3 A) H) `5 N*******************************************************************************/
2 W+ k6 [/ v5 C) P% Pvoid Delay(void)
" _, s, X. e% b* n, u{# @$ z$ }4 Z0 [2 w
u32 i;
/ ~+ P' v# B/ J% ]+ o6 [2 h for(i=0;i外设
( H% x" b- N) N" y7 o //每次传输位：8bit$ z$ D5 p% s7 t) {' _  V
//传输大小DMA_BufferSize=SENDBUFF_SIZE5 i8 j$ q- l" n
//地址自增模式：外设地址不增，内存地址自增1
! X/ N  x8 b( d //DMA模式：一次传输，非循环/ c+ o4 y$ c$ y5 s  K
//优先级：中
4 y+ t/ n6 V+ P" Z' {+ s DMA_DeInit(DMA1_Channel4);
4 d5 K) j+ \, h4 t" K DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
% Z5 S- e2 V3 E/ o- y DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;4 N* a6 |3 C: [7 T
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
0 S# ~6 f5 J& Q4 U7 U DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;. O; F! _# W5 f5 c1 D6 m7 ?$ }. O
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;; r6 h' @' C$ H3 k2 n
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
! l- c$ ]. q+ _( g DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
1 z+ p0 ~# K2 l; M" d4 X, ] DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;8 W. ?5 l% [9 W
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
; Q7 m- U/ F% F' ?# |+ v' _ DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;! g8 g. I' I  j
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;3 h: r# L+ d7 k
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
1 x3 P9 B" x7 k. j- Z+ M}

赞收藏评论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发表:& V. P! q( u# g
　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。
# K  S. O7 u- Y  y# }) g　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。
- I; u% q/ Q+ i1 b/ o8 f5 t　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
& M, u5 n5 z7 l% J0 W7 x　　这个是相应的代码例子，基于STM32F103VBT65 x; Y$ Z. R! p: q9 v
4 @. `' l0 n/ `4 W" B7 f

7 Q- q2 @* [0 F2 D# x) P/******************************************************************************4 }' K: L* Y6 s* s& I
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()8 ]7 J$ s6 W9 L0 @& h' l6 ^
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输0 U' i& G' z% y
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
& Z- A" f2 }3 p" f( Q  k* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART
) k" r: S; O8 K/ Y: d; J0 E* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可
( i+ J2 v0 Y5 y7 h7 w0 |* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止# K# B0 Q8 H* X* ~% {6 X+ n' Z
* 串口依然发送，表明DMA传输是一个独立的过程。
7 x4 Q& k* ?- b! D7 G* X7 J* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理
% {) s) b+ G, m- T8 V; ]' d* 作者：jjldc（九九）4 [0 U/ C4 U$ |9 p
* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6
: ^: [' ]5 J/ q, W1 U. P*******************************************************************************/
5 I& ?( v, C2 ^5 }+ I
) D  E( e: _7 A( _9 [: w/* Includes ------------------------------------------------------------------*/2 \! E0 p) E9 F: |0 K* u% \
#include "stm32f10x_lib.h"
/ T4 y* Y6 Y8 n0 Q#include "stdio.h"; Z& \) h( o* ?+ o2 T! i0 A8 M
3 L9 x  M3 B6 V% i
/* Private typedef -----------------------------------------------------------*/
; R) F" p0 k% `# ^% b; G" W7 R! V/* Private define ------------------------------------------------------------*/+ m+ l7 }& B% {9 ?: Q
#define USART1_DR_Base 0x40013804
) i" k4 L# p* {2 d1 X7 }+ E
; {# I! N1 E6 R7 }3 L* O- y  n+ |7 s/* Private macro -------------------------------------------------------------*/
& b) \( i1 G6 a) j$ l/* Private variables ---------------------------------------------------------*/6 q+ y! g0 U) M6 Q- n
#define SENDBUFF_SIZE   102400 a7 Z. U3 L3 V8 d, A1 {
vu8 SendBuff[SENDBUFF_SIZE];& H: Q2 L; Q" s6 m3 U- B
vu8 RecvBuff[10];
! a3 \; I$ _# d% [7 D0 @; U+ cvu8 recv_ptr;+ c7 B4 K, ]' L5 x2 V1 h9 d0 q+ b

% {. m5 r- z5 n2 y/* Private function prototypes -----------------------------------------------*/
6 s5 K) T2 F& A) F: d6 W; evoid RCC_Configuration(void);: V% o4 ?9 @$ {% h% f& o4 V4 f! u
void GPIO_Configuration(void);  A3 K+ b! H) P  z( @" m4 s0 p
void NVIC_Configuration(void);1 U2 R, N8 f  F7 J. Y
void DMA_Configuration(void);" `" @) d. J- v* }( E* p
void USART1_Configuration(void);6 k, ~& d2 |9 d3 ^% Z( U+ b& u; u

) V1 {! [/ U" ?+ _int fputc(int ch, FILE *f);% h* o6 X9 B, l
void Delay(void);
( t. q- B9 G/ G+ Z- g1 B$ d: {5 L4 Q9 p" q
/* Private functions ---------------------------------------------------------*/
- B. T) `; I  ]0 M/*******************************************************************************
" c" C, Q6 B" i2 T4 V" R0 |9 @* Function Name : main) F9 ^' R; V# B- m
* Description    : Main program.
! t7 a& P3 Y4 r: c/ f* Input          : None9 f& \( M' B2 t
* Output         : None
) o& \5 c1 r  P' N& n+ r* Return         : None- y4 D' t) S8 \! I6 @
*******************************************************************************/: [) ^/ i9 I6 u  g2 M3 `& {% n
int main(void)
0 z6 z3 H1 ?1 g2 j. K/ F" X{
9 D% l4 Q; J' h' y# V; u1 H    u16 i;5 L, L  q& A+ X$ s! m" k
#ifdef DEBUG
( u; P7 B  D2 j6 @4 L) m    debug();
: ]; I5 [  \( b) ^& x; h2 Y! \#endif
7 ]3 I( N' |: Y+ v    recv_ptr = 0;
+ ?: T& E3 k# Y4 A) [; i& {) r! B0 I
' q1 M. l9 v+ A) C# j6 K2 {    RCC_Configuration();$ {, f1 z8 D8 K" g3 [
    GPIO_Configuration();) b8 w6 t& c4 ]. p! w' Y
    NVIC_Configuration();
: [4 b1 Y: N4 r; v+ `    DMA_Configuration();
  x8 {2 B# I6 \; t6 M9 J    USART1_Configuration();
7 q8 M4 E+ d5 W4 f# Y    ( d  j/ ~, ?0 u, P; _7 h( E
    printf("\r\nSystem Start...\r\n");
' a' G" n. E. z    printf("Initialling SendBuff... \r\n");( }1 G7 U5 y; P0 }
    for(i=0;i    {
; F! l4 I$ k% Y: F8 v8 Y  j        SendBuff = i&0xff;
; o/ |) c0 ?' v4 L    }9 Y4 u  E. h% z; q/ Q
    printf("Initial success!\r\nWaiting for transmission...\r\n");+ @3 }9 n5 U. ?) @
    //发送去数据已经准备好，按下按键即开始传输
! Y/ O6 ?4 m7 W' _- L" U    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));* C# b  Y" s/ Y+ ~  f

1 _# g/ w8 T4 j9 V& p    printf("Start DMA transmission!\r\n");  v+ ?$ L: Q* g7 i4 K
    9 h  @: g% P) F' [# k7 G. h8 @
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
  b' z  P6 S4 a! ?    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);2 |% D( p# a1 D- J8 ?$ q
    //开始一次DMA传输！
2 w, y, G) B( e! e8 h% w& @4 \  I+ |    DMA_Cmd(DMA1_Channel4, ENABLE);6 j# W0 m! j# c# l
    9 c( P1 O0 @, P6 b- h2 E
    //等待DMA传输完成，此时我们来做另外一些事，点灯: e' W( U4 r5 ~. ?7 Y+ [: u3 t+ x
    //实际应用中，传输数据期间，可以执行另外的任务
0 X% E" k/ A* r: `! `7 @8 r; R    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)
- i0 P! P6 S  a# {, q    {
$ {: z1 B  ~# X& }; D4 B3 H  r        LED_1_REV;      //LED翻转( d% d- ^" j2 ^" n7 G
        Delay();        //浪费时间
( u9 H6 O6 o% j/ A! y/ G3 M    }
0 z& ^/ z& o. }2 [- }0 X  |+ X& `    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭
8 H: p5 A- k. |+ i$ K    //下面的语句被注释* \4 K6 |, c8 C1 g, n
    //DMA_Cmd(DMA1_Channel4, DISABLE);
3 P2 y- |, `- k5 j0 ]+ Q- r
* o4 C! P6 V% U# b) u. ]    printf("\r\nDMA transmission successful!\r\n");- E- c4 Q& }' U

! k8 l8 N' e; |4 F) p
  O- e( K4 ?+ X1 f6 I3 ^    /* Infinite loop */5 t8 [/ w! V/ F" A! A  k. E% \
    while (1)
% G1 S9 M& h6 d% k    {' i$ B. M$ t/ ~$ Y3 p. r2 o9 s
    }
7 W" k+ l! O; [3 O}& o. h8 `3 ^: V4 C/ W1 G% i+ U

. @; Q: f. T* R, m0 ^# ^$ N! A/*******************************************************************************- i1 K# d6 v4 M# Z/ u  i# u5 C
* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)! I3 ^! ~% X) y! ?. M" R8 q9 {! T
* Description    : 串口发一个字节7 a7 K8 n  R. W
* Input          : int ch, FILE *f8 Q) \. G* o& \7 x  ?- K
* Output         :
$ |& ^6 d# x2 {- G4 |* [+ e* Return         : int ch
" {0 S6 M1 Q, `: m* 这个是使用printf的关键
, A9 M& E, Q( o1 A8 A  m*******************************************************************************/
. }0 s& C% g# B- j) A, j* m& Zint fputc(int ch, FILE *f)7 g- W9 M4 X- o% p0 R
{
. B- W' R+ g' d7 Z* L8 i0 N    //USART_SendData(USART1, (u8) ch);3 e5 P4 p9 f  I
    USART1->DR = (u8) ch;" o9 q& B4 Y- y" v5 s. q! Y5 q0 E2 g

- U2 C3 o. R" S( }    /* Loop until the end of transmission */+ V! B/ F3 W6 w+ x2 A  C
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
( x9 a  O' t: M; E4 ]9 Y    {; }" ?* ~; q  l* y, T
    }; X7 |. W- d- J: l. B  @

" B% {7 w( B7 |9 a5 R    return ch;
) U  F8 h% r: R}
2 ~9 F/ d/ t7 P) q1 `0 o9 S
9 J% |' E& M& [. j6 o/*******************************************************************************
9 a1 ^, h5 B" F0 \" W9 w. L* Function Name : Delay
( o% n6 w2 W. R8 }2 }, e* Description    : 延时函数3 ^7 O( n! O9 S" ^0 G3 ]
* Input          : None( u1 h& j2 W3 p8 v  ^7 E: W8 L: ^
* Output         : None
/ X2 [4 h" r  g* S: Z* Return         : None
* t) ?0 e9 F0 t*******************************************************************************/5 v, |) M8 M8 l; R
void Delay(void)
! g& B$ ^) m2 p. o; R9 V3 U2 [) }{
8 F6 L( z7 `# q2 ^% b    u32 i;: D9 F0 w. ], i: j  b3 e8 d' E
    for(i=0;i外设
8 a1 n; @+ E2 n# H$ ^" M1 k6 e    //每次传输位：8bit
, G* c5 a, o" O1 Z    //传输大小DMA_BufferSize=SENDBUFF_SIZE
( S! Q: g1 A4 I- s/ z# z) L0 x    //地址自增模式：外设地址不增，内存地址自增1
2 {9 I, h7 k5 o/ ?1 M    //DMA模式：一次传输，非循环4 g( R' ?# p0 m1 z
    //优先级：中% c8 n8 W4 T' W0 S3 |% {
    DMA_DeInit(DMA1_Channel4);
4 z! P' S- e" C0 y* Q& G7 H* k    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
& Q5 Y% e- H0 S  d9 B' s% r4 i    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
7 l1 C- r6 g5 Y8 [+ J7 }    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
9 F; b5 @% l- m8 H    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;1 `# k0 M2 T6 `; g. m
    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;' S& c# u" L$ d1 b8 p& e2 v+ m) `
    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;7 R6 M8 P9 ^7 c3 R+ B
    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;6 K" \" B3 |5 E2 o+ n8 x/ c  y6 t
    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;! v; M8 [" C' }; n2 @8 q+ R& i5 j
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
- j9 x/ V0 j9 W1 h    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;# x2 l  r, P0 L3 W& H& M7 O
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;+ V( T( }7 P8 I9 }- R( ^
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);' j- M9 }. F4 h' [% Y
}