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;
& [( H$ S5 Q: ^ }3 ?7 \) Q  i% i( d8 G9 N
printf("Initial success!\r\nWaiting for transmission...\r\n");. p8 m# V- z' p4 H
//发送去数据已经准备好，按下按键即开始传输
! P3 r5 t' j3 l% Z* s while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));
7 O. {6 B9 M$ X$ a9 P# h
printf("Start DMA transmission!\r\n");  P' f! ?/ Q/ d6 ~

  j  C; Z! o; Z" Y3 C2 K& ] //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作5 s, V" H; F( ^- M$ c6 o
USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);- z% i) d7 T) O7 Q
//开始一次DMA传输！
1 u8 n9 T! h" w DMA_Cmd(DMA1_Channel4, ENABLE);! h  P; v5 r! d0 O3 ?  ]4 j6 U9 k7 D

! B: g7 ]3 C! O: \% O //等待DMA传输完成，此时我们来做另外一些事，点灯' r: g. v; ?+ `
//实际应用中，传输数据期间，可以执行另外的任务! k7 l( k/ e- Y  J
while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)' Z8 s6 C; s5 i( U0 ?2 G8 h
{1 `! M5 Y, z0 y8 P
      LED_1_REV;    //LED翻转$ G: a  C" O" r' ]
      Delay();       //浪费时间
! M% B3 d" D  T" W2 r4 e }
7 S/ X& }4 z% t //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭1 K* |% ~& m* N% R1 R9 H
//下面的语句被注释7 e# k% _8 ]1 K% W: z( b
//DMA_Cmd(DMA1_Channel4, DISABLE);) I1 s- c" ^% U6 U# }
; H7 s; L1 ^" Y0 _
printf("\r\nDMA transmission successful!\r\n");+ K) `  G( i/ ?# H( L

/ u% k, f! }0 q4 h9 P- z
* X/ a2 `& L/ P7 O /* Infinite loop */
8 P4 U2 f: N2 k" }, H+ I6 a  k5 T/ ~ while (1)
' }( w, b! d. H1 } {! f4 O2 S6 _7 ?" G, |
}- Q6 z  ~4 h! K2 d2 s) d
}$ D. ~& x3 n. u1 N

* L9 }* L. ?% v$ ]/ z* H5 B/*******************************************************************************+ r) [. y+ I& N
* Function Name  : 重定义系统putchar函数int fputc(int ch, FILE *f)
* Description : 串口发一个字节# V$ l% P4 E) H* k
* Input       : int ch, FILE *f- e3 F5 C# i% b) u: I
* Output       : $ B- {" {/ V% Y) h7 k# ?, N* f4 K
* Return       : int ch7 M5 r- z( s2 `6 ]0 h' J- K
* 这个是使用printf的关键
" a; Q8 O; W" T+ q) {7 F* c# L*******************************************************************************/8 Y, L/ c4 O2 w2 c
int fputc(int ch, FILE *f)+ u4 W; A+ ~6 X& @$ e: C8 F
{
, V6 S$ D  ~% Z0 `/ _ //USART_SendData(USART1, (u8) ch);
/ k( F: [, C9 n7 r USART1->DR = (u8) ch;7 J8 y" @/ |! {0 k& U6 ~
1 j: R7 A+ \$ j8 x( l+ o
/* Loop until the end of transmission */9 I* U8 N! ~) Q0 s# L+ V
while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)0 W, H: g, g$ t2 R2 c5 B
{
/ g4 z1 l! i4 u7 L. c0 L }# ]4 n* v! w( v; Y0 L5 ~: Q+ o2 `
; j6 y1 f! m  \& z3 Z/ x" K, F3 j
return ch;2 O& w5 w  O) ]- |  v% b
}' ]4 e% j; O& ^" J0 H

! W4 X+ h9 b9 Q1 E8 d: H/*******************************************************************************) O: {+ x5 Q4 W+ X: o$ G4 Z9 L
* Function Name  : Delay
: l  o7 F7 \9 U7 r( i3 _# B* Description : 延时函数$ w+ W) _. |) g
* Input       : None
* e! [9 H+ \) L: Q% I* Output       : None
# g* D: v1 P8 G) d! y8 D0 R* Return       : None
' P, n) ]  E$ A4 d*******************************************************************************/
' D+ z2 L! w  x& q' l3 e& {. Vvoid Delay(void)
# \4 A' p( H  A2 `' O+ Z# R5 F8 F8 n{
# B& b/ ]* P' {& S7 P) V u32 i;
/ _) Z; C6 u+ }5 l  F0 x for(i=0;i外设
* H- b8 j" `) h) z2 R //每次传输位：8bit" b- Z! P' j% @$ T4 k* O: \
//传输大小DMA_BufferSize=SENDBUFF_SIZE7 }( ]( U. G6 j
//地址自增模式：外设地址不增，内存地址自增1- \$ ?7 g8 ^. x( x" r* R
//DMA模式：一次传输，非循环7 C" r4 X: @/ k9 `0 K/ s; ]
//优先级：中. j9 y5 k  N, G2 \: T
DMA_DeInit(DMA1_Channel4);% g# v: O. H5 _6 h0 u
DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;
+ u% |9 z6 @; @* s DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
+ i  Z# L+ g  \( D  K( o& _ DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;; d# b# u' h* l
DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;0 Q0 [( w* s) T, O% U2 g% C
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
+ j$ b- L; l% ~3 R2 s DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
6 O8 F6 h; S3 E* d DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
, q+ Z' `, W; i4 c2 x4 h DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;2 l& D  \* N" h) l& `2 b: I/ I
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
( W' ~# J% ]  ~  Z3 w0 ?' W DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;0 X& [7 `+ ^4 N) Q; y% z  S" V! H
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
! d& J$ Z* g$ \; Y) G+ @ DMA_Init(DMA1_Channel4, &DMA_InitStructure);" q# c/ {4 h/ O! k, j
}

赞收藏评论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发表:
6 A* O, B+ L% U8 E　　这里有个小小的例子，来演示DMA模块与系统程序并行工作。: [  G: q! s; I5 X7 _  N5 q
　　用串口以低波特率发送一个10K的数据，花费近10s时间，此时按照以往方法，CPU要不断等待数据发送、送数据；或者送数据、进中断、送数据，处理起来比较消耗时间。( A# G5 S5 q% @, r* {
　　使用了DMA功能以后，用户程序中只需配置好DMA，开启传输后，再也不需要操心，10K数据完成后会有标志位或中断产生，期间可以做任何想做的事，非常方便。
7 t( i9 A" G/ ~1 O　　这个是相应的代码例子，基于STM32F103VBT6
; M7 B$ O; Y- Z1 J
4 |+ O# @, W- V8 ]5 l7 |5 f( {) m# l% t+ I1 M
/******************************************************************************. u( W* F" T2 l0 M. i
* 本文件实现串口发送功能（通过重构putchar函数，调用printf；或者USART_SendData()5 u' l) _: k" W' Q7 J$ ^3 y' e5 I7 z
* 这里是一个用串口实现大量数据传输的例子，使用了DMA模块进行内存到USART的传输* @. W2 y) F  z" c$ f' I( U+ w/ D
* 每当USART的发送缓冲区空时，USART模块产生一个DMA事件，
2 D6 `, g  N* F% `1 i* N* 此时DMA模块响应该事件，自动从预先定义好的发送缓冲区中拿出下一个字节送给USART) X( e' K3 d! c9 Q5 D) T, F# r) J5 \
* 整个过程无需用户程序干预，用户只需启动DMA传输传输即可2 R4 r* q  w( m" G, ~! }
* 在仿真器调试时，可以在数据传输过程中暂停运行，此时DMA模块并没有停止
7 s3 J' B9 E# V# e* 串口依然发送，表明DMA传输是一个独立的过程。
3 N$ x( x, E2 R2 H  @; V* 同时开启接收中断，在串口中断中将数据存入缓冲区，在main主循环中处理. M- G1 U8 r- P# ^2 f
* 作者：jjldc（九九）
  C4 y3 J( g/ ?& n1 ]* 代码硬件基于万利199元的EK-STM32F开发板，CPU=STM32F103VBT6- g( K, Y( t4 B; \
*******************************************************************************/
" v1 u9 t% i6 |4 z; x0 I" C  w+ J
/* Includes ------------------------------------------------------------------*/& y3 N' r- ?1 P; e9 e* d
#include "stm32f10x_lib.h"
! I) Z' s( D( X! J#include "stdio.h"
; ~. c& K: C, Z: U% e: r" ]8 D3 t0 X5 }
/* Private typedef -----------------------------------------------------------*/
7 E. u: D5 ]( E/* Private define ------------------------------------------------------------*/! m" n$ K4 x/ m+ O  s0 U5 r
#define USART1_DR_Base 0x40013804
: V9 Z0 S* ^2 B; v4 T4 i$ ^& L5 c; t9 t3 K- @
/* Private macro -------------------------------------------------------------*/1 y6 N2 o6 w+ `, b: B
/* Private variables ---------------------------------------------------------*/
& j4 |2 |$ S2 o% p* O#define SENDBUFF_SIZE   10240" K' _; {3 f0 C3 A" V; B5 `
vu8 SendBuff[SENDBUFF_SIZE];2 r& P/ ^( H7 i' t3 c5 K
vu8 RecvBuff[10];' `) [; H( n% Q* ~& o+ O% Z# K: H/ ^
vu8 recv_ptr;+ L! L( R  Q1 a" ?2 j; y
0 Q+ c- x' A% l( ?' w
/* Private function prototypes -----------------------------------------------*/
" X  m0 `7 Q- S8 E: X0 n8 Zvoid RCC_Configuration(void);
8 k* A4 U  N- v  U8 F6 l! W$ Jvoid GPIO_Configuration(void);" l4 `0 B5 s7 E3 A6 v6 ?% i
void NVIC_Configuration(void);
# n2 @' g+ g+ d+ f$ T3 _7 F  S7 k# hvoid DMA_Configuration(void);
- I6 t  \" R5 J" i# _  mvoid USART1_Configuration(void);
& ~) @4 W/ j0 \! d
+ b  E" u- i0 X8 Qint fputc(int ch, FILE *f);. v# k2 E7 K$ n2 j1 a& z
void Delay(void);
( a1 Z* A5 J9 ]! n
/* Private functions ---------------------------------------------------------*/
6 g' A' x" ^' m* G9 L# X/*******************************************************************************
" {3 }# F- X7 a' I8 w7 a1 z/ D* Function Name : main/ v2 B4 F% q! [! r6 A# d
* Description    : Main program.
' |6 G3 z- @! h# _* Input          : None
! e, N! P0 k0 O5 S. I& }  {; Q* Output         : None
/ g. X% ~' N! R4 L6 L* Return         : None0 X" X5 Y. x/ K! Y- ~: m
*******************************************************************************/4 C9 o# I% X- r( u
int main(void)
  f( `/ v7 }' i2 _0 ~, L0 H/ H{3 H4 }& Z9 O% k2 f: M
    u16 i;
5 \+ L$ u$ F. G1 z# C#ifdef DEBUG
/ @8 x! ~3 \# ~4 t5 l1 O# F    debug();
( i" x. N1 W: N. i#endif# e4 q% n4 V% W( g! U. Q
    recv_ptr = 0;
& S  e2 l9 S/ Q3 j
0 j4 ~8 V7 j+ r- r    RCC_Configuration();4 ]: P: M7 s8 S% R7 s; ?$ W6 Z% i
    GPIO_Configuration();) r% q  D: v4 g6 K
    NVIC_Configuration();
6 z3 {- z- _' `- T5 u2 }1 b    DMA_Configuration();% X0 l, m5 k5 |# O! Y. K
    USART1_Configuration();
7 r) L. P& j1 h/ ^6 h; V& M9 k6 ^
$ ?8 W# }! U6 U8 }9 {    printf("\r\nSystem Start...\r\n");) x/ Y% {2 p! n
    printf("Initialling SendBuff... \r\n");9 d# e6 _, J% @+ _& U  }! h
    for(i=0;i    {& D. Q: U. u* c3 ]& d+ K# d9 r$ l9 L
        SendBuff = i&0xff;
: X  u8 f  F% I! M, J  R    }1 R$ Q8 }+ U9 S7 e2 U& I
    printf("Initial success!\r\nWaiting for transmission...\r\n");: \. I& {5 Q- \+ y; Y4 [
    //发送去数据已经准备好，按下按键即开始传输
( v( V2 H! I! }3 @4 a    while(GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3));' u: l: o2 P( k; S+ I" Y
    % l( X- D4 G! |7 F6 k1 @: c( w2 {
    printf("Start DMA transmission!\r\n");) F1 I0 z2 S! c
    4 u6 R: n; d% ^8 P" @/ A
    //这里是开始DMA传输前的一些准备工作，将USART1模块设置成DMA方式工作
0 O2 f  S: b. g' j, z" M    USART_DMACmd(USART1, USART_DMAReq_Tx, ENABLE);
5 m$ v) C( S8 [8 k: z9 F    //开始一次DMA传输！
- I5 H4 V  |/ ?) P$ W# X; A    DMA_Cmd(DMA1_Channel4, ENABLE);
4 Q7 u( B8 [( ]- S
; x" R: y! y9 W6 _    //等待DMA传输完成，此时我们来做另外一些事，点灯
% O* c8 L9 ?! M: R7 _9 k9 W    //实际应用中，传输数据期间，可以执行另外的任务! ^; P+ K. V/ |9 v3 t0 _
    while(DMA_GetFlagStatus(DMA1_FLAG_TC4) == RESET)# H. ]# e: a$ H" }/ S- j1 V, m
    {
" T) S2 f- ]- r" \+ |        LED_1_REV;      //LED翻转
        Delay();        //浪费时间% s0 z2 s; P2 D- m* ^! m
    }2 Y! z7 N& \: n5 F
    //DMA传输结束后，自动关闭了DMA通道，而无需手动关闭: f* f1 S; l; E3 O
    //下面的语句被注释) R" N, P3 a, K0 T- L
    //DMA_Cmd(DMA1_Channel4, DISABLE);
, A4 P; c+ ?8 n% h: d, }
0 p4 J; s% W0 `$ L, k8 i. E    printf("\r\nDMA transmission successful!\r\n");
1 c7 }5 K( ?" k/ \  K8 @7 X5 U& L! P, i6 `8 J; r
    5 f  ?- L5 h8 w0 h
    /* Infinite loop */( v, W( _+ Q; a7 F  Z
    while (1): n& k4 r4 g; u9 J5 b
    {
    }
& U- p  J7 S# z6 {3 g}4 I7 W9 _0 z2 D* `2 c1 Q) w

& e* h% {- {4 k0 [  A/*******************************************************************************0 u! j( f  N  u4 c" C  g) A
* Function Name : 重定义系统putchar函数int fputc(int ch, FILE *f)
. e% ?+ K/ S5 W9 u* k% h' c3 e  V* Description    : 串口发一个字节' e- X  M5 S+ z/ c2 Q2 m
* Input          : int ch, FILE *f. F4 S# T/ t+ N  A
* Output         : ( p6 X0 E9 h: S7 O; {
* Return         : int ch+ [3 G  h* `- ~1 f
* 这个是使用printf的关键6 `& Z9 F: j$ P& o- @+ b: `
*******************************************************************************/% L4 G5 j4 M5 {$ q
int fputc(int ch, FILE *f)  D' L% m' m6 A
{
+ U8 I& U$ M! i% a    //USART_SendData(USART1, (u8) ch);0 z! l: y3 s) E# J4 _
    USART1->DR = (u8) ch;
+ k8 K( T8 o6 l5 z5 j! K: e# N    8 m" w2 ^4 c, \5 a8 F* U
    /* Loop until the end of transmission */
! y6 `1 ~( W+ d- T/ L9 D7 j* |    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
# y% a: `# w  g$ R    {( z% G0 N0 v& S7 s
    }
$ c$ o( J: S9 O' n9 b+ @2 t
( K7 k( n# g; O. s# A    return ch;
& h% T6 c7 m- p  x6 m) X}3 v. [% Y8 P; B- Y5 g; l& b5 U2 V
1 |4 q& u5 w3 E
/*******************************************************************************
& W1 o7 c6 @/ f: K# M0 @/ [4 l* Function Name : Delay* A, y8 p4 w; R9 W
* Description    : 延时函数& q& h1 S" Z; q( y* G8 F
* Input          : None& V4 e6 L& N$ {- L+ Z) N+ v/ {+ X
* Output         : None' ^$ d% p9 S+ I7 S. y
* Return         : None
1 T6 R* e0 E  F" O$ n; ]*******************************************************************************/. q0 y% d$ N  n. g
void Delay(void)/ M! i* g7 ]; R" y' l
{- z+ J3 u) _1 _- x9 _
    u32 i;* ?; |; m" `6 Y& z6 n9 _! f
    for(i=0;i外设# ~- |$ M+ v4 ~$ ~) z8 A% s: a
    //每次传输位：8bit
2 Z4 j% d* Z* Z" w% g; }: M    //传输大小DMA_BufferSize=SENDBUFF_SIZE
$ b/ C- {' h# S% Y5 }0 f  U' T5 ?    //地址自增模式：外设地址不增，内存地址自增17 D6 P. L, ]. r
    //DMA模式：一次传输，非循环) `* N! A) g7 Z$ Y% a$ L! M5 e
    //优先级：中
7 ~* j4 F. {1 P, z+ ?    DMA_DeInit(DMA1_Channel4);& V7 N' c: Q! f6 X
    DMA_InitStructure.DMA_PeripheralBaseAddr = USART1_DR_Base;% J) |' H2 u$ w& b8 ]% I
    DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;
9 \! B$ P/ V# s5 h, b& m# w8 A    DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;1 d* }( c9 Y% m  g0 B9 r# y1 h
    DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
- G1 x$ T; j- O# v# r' S- ~; i    DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
4 O: z4 L2 ^3 b    DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
. S8 c; J" x% `0 }& b; j  ~! ^    DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
+ E; y, i2 j' R5 j/ y    DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;5 M4 W9 a+ c9 B- ^  w! n
    DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;# n& ^- Q( J& O( Z! A
    DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;& P( F+ N9 a* I3 o
    DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;7 K& H% E- d9 I! s" e2 y% t
    DMA_Init(DMA1_Channel4, &DMA_InitStructure);+ r) E, |4 E" q% i: f
}