【经验分享】stm32之串口通信DMA传输完成中断

[复制链接]

STMCU小助手发布时间：2022-1-16 17:43

文章
文章封面:
文章简介:	首先唠叨一下DMA的基本概念，DMA的出现大大减轻了CPU的工作量。在硬件系统中，主要由CPU(内核)、外设、内存(SRAM)、总线等结构组成，数据经常要在内存和外设之间，外设和外设之间转移。

一、DMA功能简介

　　首先唠叨一下DMA的基本概念，DMA的出现大大减轻了CPU的工作量。在硬件系统中，主要由CPU(内核)、外设、内存(SRAM)、总线等结构组成，数据经常要在内存和外设之间，外设和外设之间转移。例如：CPU需要处理从外设采集回来的数据，CPU需要先将数据从ADC外设的寄存器读取到内存中(变量)去，然后进行运算处理，这是一般的解决方法。CPU的资源是非常宝贵的，我们可以设法把转移的工作交给其他部件来完成，CPU把更多的资源用于数据运算和中断响应上，如此DMA便登场了。DMA正是为CPU分担数据转移工作，因为DMA的存在，CPU才被解放出来，它可以在数据转移的同时进行数据运算，相应中断，大大提高了效率。

二、DMA的主要特性

三、DMA中断特性

四、DMA之串口通信

　　我们实现一个简单的功能，在DMA中处理串口通信，把数据转移的工作交给DMA，DMA把数据从内存(数组)到外设(串口)的转移，在main函数中不断进行闪灯操作，这样我们可以看到DMA在工作的时候CPU也在工作。非常有必要复习一下DMA的对应关系，我们知道stm32总共有2个DMA控制器(DMA1有7个通道，DMA2有5个通道)，每个通道专门用来管理来自一个或多个外设对存储器访问的请求，还有一个仲裁器来协调DMA请求的优先级(优先级分：很高、高、中等、低)，这可不是随便对应的。

1、LED初始化程序如下：

void LED_GPIO_Config(void)8 L- V0 X. n; I1 B1 Y$ h
{
0 H# ~- S( t9 i/ O; `3 h( f5 b
/*定义一个GPIO_InitTypeDef类型的结构体*/
" V% C/ u4 r) G4 [2 F
GPIO_InitTypeDef GPIO_InitStructure;4 i7 r. j* F$ U1 I' K( b* j% o
/*开启LED的外设时钟*/
# A- K+ s) b9 e
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE);# M5 |" Z7 V# S; g U* }
/*选择要控制的GPIOB引脚*/
- p2 g7 n/ f1 A+ h! p+ A% A5 O
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14; * g7 i, r, O8 C, v% {
/*设置引脚模式为通用推挽输出*/
1 H! `" E& T) H' l
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 7 r7 g" ] p$ n. i: L' L# o
/*设置引脚速率为50MHz */ , _) V. U v3 w1 `. _1 f
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;4 o5 P9 Q. ~5 m; I5 Z
/*调用库函数，初始化GPIOB0*/
* b: I \0 @& J
GPIO_Init(GPIOB, &GPIO_InitStructure);
Q- H/ v2 X7 K* J' n! g/ |1 R
/* 关闭所有led灯 */* d5 f& F1 S+ h- X4 l7 F
GPIO_SetBits(GPIOB, GPIO_Pin_14);
i0 Y5 C# f3 k: v
}

复制代码

　　这个地方地方没什么要注意的，唯一要注意的就是输入输出模式，我们按需求这样配就好了。

2、串口初始化

void USART3_Config(void)
( i; @9 {) @% y7 q& I$ h/ {* W
{
% {$ L. R G T3 f, i6 v4 Q: W
GPIO_InitTypeDef GPIO_InitStructure;
- F: Y+ [+ i% g. k
USART_InitTypeDef USART_InitStructure; 8 O6 E @" |, W
/* config USART3 clock */
- f& ]/ i! ^: X. F8 j
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB , ENABLE);
6 U. B# L; E9 C Y2 Y9 b5 `; ^- u, S
RCC_APB1PeriphClockCmd( RCC_APB1Periph_USART3, ENABLE);6 C' M9 Y ]$ \' m
/* USART1 GPIO config */ L! h) m: h+ \7 u7 q r! a ?4 ?
/* Configure USART1 Tx (PA.09) as alternate function push-pull */
& e$ W+ U: _) v7 I" l: d$ M- _
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
& E# R; ~8 }5 I: w
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
9 L; T* l M* A1 v" L5 b) S
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
9 A5 [& N: Y) x$ v$ P9 v
GPIO_Init(GPIOB, &GPIO_InitStructure);
8 P# z! m( d2 z, q7 L( t$ t2 }2 f
/* Configure USART1 Rx (PA.10) as input floating */* J, m0 G% k4 ~/ A% \2 S
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;. {8 k0 ~ l: v5 y( d9 N+ \
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;/ i, S$ w# l0 N3 k9 G. H9 r* v+ O- d
GPIO_Init(GPIOB, &GPIO_InitStructure);
+ ]3 c" u" i# }
/* USART1 mode config */1 `( @) H: T/ Y! }
USART_InitStructure.USART_BaudRate = 38400;9 [% M$ ~0 h, N( W% S
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
' W' Z. J) c7 L' z+ O, J
USART_InitStructure.USART_StopBits = USART_StopBits_1;7 c& p7 S/ z/ w' @$ h0 `
USART_InitStructure.USART_Parity = USART_Parity_No ;* t. B& Q* w3 m$ q$ @& n
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
$ U1 U [; Z; h8 M" }: M/ a) t
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;# L9 @/ t9 V$ a3 P9 h
USART_Init(USART3, &USART_InitStructure);* p9 b+ u/ m$ i
USART_Cmd(USART3, ENABLE);
* M5 S" t0 i* e9 S5 a
}

复制代码

[/table]3、DMA初始化

void USART3_DMA_Config(void)
% y& H; M$ s) i" }
{
3 e6 t! p' z f) H1 q- d; K% i6 O
DMA_InitTypeDef DMA_InitStructure; ; C8 F% |7 m( ?' U: }6 p( o
/*开启DMA时钟*/$ v* f" a2 v( j2 i8 D K9 I
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
2 U. G0 G7 E% B/ G" m
//NVIC_Config(); //配置DMA中断7 f; O: F" O# Q
//NVIC_Configuration();% U2 _. C- \* j6 Q& ]4 n& _+ m3 ^
/*设置DMA源：串口数据寄存器地址*/: g ~, R% P( ]! `
DMA_InitStructure.DMA_PeripheralBaseAddr = USART3_DR_Base; ' e5 c& q# n7 c+ |
/*内存地址(要传输的变量的指针)*/4 ]7 G" e$ m/ K, p" e& _0 B
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;& d1 D) f/ n6 T' a9 g
/*方向：从内存到外设*/
& n+ d8 u5 s7 c' w" _
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST; ' E0 x; r1 Z4 L4 K" T( _
/*传输大小DMA_BufferSize=SENDBUFF_SIZE*/ 8 h6 P/ E3 F1 `8 E
DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;6 W+ K1 c, Q/ g$ S
/*外设地址不增*/
) P- u: I- ~9 f+ h" i& X( z, R- A. E" N
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
# N% c; R* m2 j+ b
/*内存地址自增*/
. ?1 A( E6 {4 q2 a5 F
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;: p# ^! t, \! \! U) ~
/*外设数据单位*/ 8 y7 s$ f& V4 D5 F$ p/ u! ?8 n
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
S$ u0 {1 f& F' u. K( _5 O
/*内存数据单位 8bit*/8 m% }, {+ ?- Y$ k
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; 9 C# `$ w; s# h0 u: W# r% ~( C* b
/*DMA模式：不断循环*/
( u* D& k6 i3 Y. @, K6 T0 p
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;
+ f' [$ {3 h: H! Z( o9 H m& a8 I5 E
//DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; ; D5 `* A" B1 S1 |. Y3 E7 j* \' _5 G
/*优先级：中*/
1 H) n4 ^0 Q& x$ r2 l, e
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
$ ^% X! W. d8 [# ]
/*禁止内存到内存的传输 */
" U6 `: m3 e9 c3 X8 w3 D2 t0 r3 `
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;0 c, e& z' ~4 |0 O& {& C
/*配置DMA1的2通道*/
' x6 M' k' z- N0 R
DMA_Init(DMA1_Channel2, &DMA_InitStructure); 0 T6 T0 m, W' a" e! R6 g: Y
//DMA_ITConfig(DMA1_Channel2,DMA_IT_TC,ENABLE); //配置DMA发送完成后产生中断
# U6 u b; [; r1 l" h$ Q7 p& H
/*使能DMA*/
# |& z5 ~8 g- P o
DMA_Cmd (DMA1_Channel2,ENABLE);
N, g( o' }/ Z4 c! k( d
}

复制代码

在这里我们要注意以下几点：

(1)DMA_InitStructure.DMA_PeripheralBaseAddr = USART3_DR_Base;这里对应USART数据寄存器地址，这个地址我们是这样定义的：#define USART3_DR_Base 0x40004804，这个值是怎么算出来的呢？我们可以查看stm32存储器映射表：

USART3的起始地址是0x40004800,我们查看stm32串口数据寄存器偏移地址为0x04

因此我们可以计算到USART3数据寄存器地址为0x40004804

(2)我们数据传输方向内存(变量)到外设(串口)，所以DMA方向为内存到外设

(3)DMA传输模式有两种：DMA_Mode_Normal(普通模式)，DMA只传输一次；DMA_Mode_Circular(循环模式)，DMA循环传输，比如在AD采集时要配置成循环模式。

4、主函数

int main(void)# I' y7 q+ e! J, v6 ]5 S
{
/ Q+ p$ u# T' h5 C- y
/* USART1 config 115200 8-N-1 */
c) L N; S3 }1 g- n+ H
USART3_Config(); ! V- u. j6 s% M C2 t0 ~
USART3_DMA_Config();
" Z2 L- F0 r: z; K7 r8 p
LED_GPIO_Config();
4 c# |4 @% j- {1 M F, y
printf("\r\n usart3 DMA TX 测试 \r\n");
* k1 l9 A* Z# G8 l3 Q0 U
{, ?) C( q4 n- N% I1 m
uint16_t i; + y5 k/ R! h* p9 r) v: J b
/*填充将要发送的数据*/$ j4 M8 J# G, A2 ]' w, E( j
for(i=0;i<SENDBUFF_SIZE;i++)/ T( ~) T( h! `* G
{* |) Y. \5 N5 ^! p* Q0 Z
SendBuff[i] = 'A';
) h$ O7 p! o. b' r7 U z
}0 p/ C0 Y, x$ r5 x5 `6 L2 Z- V4 E
} + B/ y* {" {, S# }5 b( `4 v
/* USART1 向 DMA发出TX请求 */2 V* D& M( S1 C% k: c( U I+ j+ x/ y- F
USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);' }2 L: m% s$ P/ }% k' N6 d
/* 此时CPU是空闲的，可以干其他的事情 */
# @2 P$ v0 y1 Q( L
//例如同时控制LED
: f7 L5 l7 ~, ^8 c ^
for(;;)
g7 y0 B& M, x* k- n+ B
{! }2 F E* ^9 k$ C6 `3 C p8 U- A% i
LED1(ON);* c# R: G4 k! h8 s& A% m
Delay(0xFFFFF);( j+ L2 b9 L/ _$ B' R
LED1(OFF);% v: j; A* e+ L$ G
Delay(0xFFFFF);
3 W0 |; E, f! W f
}# Z2 V/ j: K0 R5 K$ k! Q; S
}

复制代码

这个函数很简单，我们很容易就可以实现，达到效果，这里就不贴图片了。

五、串口通信DMA传输完成中断

　　我们知道DMA可以在传输过半，传输完成，传输错误时产生中断。我们实现的功能是，DMA工作在普通模式下即只传输一次，LED灯初始化是关闭的，DMA传输完成后产生一个中断，在中断中我们做点灯操作。这个程序调了一天才调了出来，并不是因为它很难，而是有一些要注意的地方没有注意到，从而到时耽误了好长时间才调出来。不过有错误就会有进步嘛。

　　我先贴出正确的代码，然后在讨论我犯的错误，由于和上一个程序好多都是一样的，这里我们只贴出不同的地方。

(1)DMA初始化程序：

void USART3_DMA_Config(void) D8 d* n- A' p0 i
{
2 Y8 t- o! w' V
DMA_InitTypeDef DMA_InitStructure;
; Z8 @" A2 i4 V4 I9 s" j; e
/*开启DMA时钟*/7 Y0 Q7 D# Z( l* h" ?! Q
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); ! s# }* O0 \3 e8 d
//NVIC_Config(); //配置DMA中断
* Z( I) g. e( R. T4 l# T
NVIC_Configuration();3 }; t! V0 Z0 W( J5 q
/*设置DMA源：串口数据寄存器地址*/
8 c( I# O# j* l1 r6 n C- w/ V$ r
DMA_InitStructure.DMA_PeripheralBaseAddr = USART3_DR_Base; 2 |+ H$ d+ Y* Q! u
/*内存地址(要传输的变量的指针)*/' R2 n9 p5 q- G' \1 X" J9 x
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)SendBuff;: p; n# p- a8 @7 }4 T! i
/*方向：从内存到外设*/
! T* c; e& G# i6 D& k5 z
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
9 ^* v. ^4 u! o8 f% |
/*传输大小DMA_BufferSize=SENDBUFF_SIZE*/
. o+ R* v5 V' u8 s1 A
DMA_InitStructure.DMA_BufferSize = SENDBUFF_SIZE;
8 n3 G9 O/ r5 j* k7 D2 r9 J
/*外设地址不增*/
2 p! |8 }+ H' i
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
z. K# J5 w$ X; b7 ?
/*内存地址自增*/
! e( ?; }! V: l( W! ~1 J
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
# }# j( M7 R6 \# x4 e+ d" v0 e
/*外设数据单位*/
& \% O* r* S: q; O/ E5 o9 c X2 m
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
& F) u+ s# }0 m* E6 ]
/*内存数据单位 8bit*/$ w' } `0 c0 }8 @# s
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
6 A% j/ U7 V0 V# u
/*DMA模式：不断循环*/
- H+ b9 g4 Y3 N" G' o
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal ;+ d+ d7 n# k& a) u' e
//DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
6 x% b+ s- W% n q
/*优先级：中*/
3 N8 m8 H* W/ O" x
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium; # g2 n; u2 r/ W5 A4 l3 m" \7 q# F1 |
/*禁止内存到内存的传输 */
1 V# s) R% O4 J: k/ _- x# ]8 s
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
N" e& @3 D s3 ^* I
/*配置DMA1的2通道*/
. n" `* L) {1 F7 ]2 @; c
DMA_Init(DMA1_Channel2, &DMA_InitStructure); " I: W n5 N$ K0 N
DMA_ITConfig(DMA1_Channel2,DMA_IT_TC,ENABLE); //配置DMA发送完成后产生中断
" x5 }7 G8 {. Y' U
/*使能DMA*/
( k- ?& t% Z/ S4 q5 |
DMA_Cmd (DMA1_Channel2,ENABLE); 0 V5 ~6 m. m0 Q+ y. i" y: e4 ?
+ C) T$ X( W' L, T6 S t- s6 ]; L
}

复制代码

注意我们在这里打开了DMA传输完成中断。

(2)NVIC初始化

static void NVIC_Configuration(void)' A, T* w: S' D9 y& p% _
{
$ h" s' E" F {; H
NVIC_InitTypeDef NVIC_InitStructure; /* Configure one bit for preemption priority */
3 q2 }* b1 D+ K2 v; O7 n# g$ I
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
4 K* G$ N7 E. `+ _) {/ F" s
NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel2_IRQn;
/ v/ N8 }' ^8 |- A- ?. ` v
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
" v- \9 [9 S- N0 C# z
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;1 G7 R4 a2 D1 f7 m4 a
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; * W/ u# g4 M' k+ t. C, U E
NVIC_Init(&NVIC_InitStructure);: d! h. R$ R s( ], c: C
}

复制代码

(3)中断处理程序

我们在stm32f10x_it.c中编写我们的中断处理程序：

void DMA1_Channel2_IRQHandler(void)! O- q% r" |1 b" [" |/ s
{
3 @) l& U" { F
if(DMA_GetITStatus(DMA1_IT_TC2))
1 M) }1 a; P8 I9 R
{
" u3 E' ]$ l/ W6 V* u% h
LED1(ON);
& @# {) c6 z' r v4 F
DMA_ClearITPendingBit(DMA1_IT_GL2); //清除全部中断标志
* ?5 R) m3 q: F8 ]0 \: X
}
, Z3 R7 A3 m( \2 ?$ i0 b& Q+ V
}

复制代码

我们也可以这样写中断处理程序：

void DMA1_Channel2_IRQHandler(void)$ @ }1 X: T5 N" J. w
{
8 J3 H" k% q6 V6 Z1 i. J
if(DMA_GetFlagStatus(DMA1_FLAG_TC2))
. }; \. _# X8 D4 k
{0 S, E; x/ \. j. x
LED1(ON);
/ t9 | e; a8 _7 s A' F& G
DMA_ClearFLAG(DMA1_FLAG_TC2); //清除全部中断标志) k( X" |$ Z# H7 o
}
. p2 ]8 I: q3 M9 K: z
}

复制代码

这两种写法都行，我们在库开发文档可以查看。都代表DMA的通道2传输完成中断。　　

(4)主函数

int main(void)
: K; @4 b ^5 V# r8 T; F
{3 E$ p5 I& c$ d+ i# G
/* USART1 config 115200 8-N-1 */
7 m" A9 q, ?* i" z3 a, c) }$ @
USART3_Config(); ) L" q& `/ U# \
USART3_DMA_Config(); ) u& t. E* U# v: i) ~5 A
LED_GPIO_Config(); # r' T5 n( W" V" J, d: g. C) o9 H, l! O
printf("\r\n usart3 DMA TX 测试 \r\n"); y7 w3 A5 y- X, n* I, C
{
# S1 U' z$ f3 i: i; [) {
uint16_t i;
! P/ V. }; t W: B
/*填充将要发送的数据*/
* p7 m& T( {3 Z4 V j0 X
for(i=0;i<SENDBUFF_SIZE;i++)
$ F- j" O' l5 n2 B5 a U& ^
{" p+ U3 F1 {% n: R4 `( N
SendBuff[i] = 'A';
2 g/ [* u* a @* J ^! U
}
2 n( D5 p! t2 R" `" ^
} 1 C" d2 b, ]% [+ p
/* USART1 向 DMA发出TX请求 */
3 N1 C2 ?, e5 q, ], v0 A' _
USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);! l6 N" a6 @2 T' ?6 e, C" I! }
/* 此时CPU是空闲的，可以干其他的事情 */
! w# z; |# V2 n8 E m5 S
//例如同时控制LED
* r8 v. s& d- u
for(;;)2 F, g X. s! R% a& u
{
7 E* [, I. r5 i( ]+ s. C
}* O, }( z& L. J Z' n3 l. Z
}

复制代码

[table=98%,none]

这样我们实验便可以看到，LED灯初始化是关闭的，当串口发送完40000字节的‘A’后，LED等亮。

(5)补充

原意是测试DMA发送完成中断指的是每次指定字节发送完成后便产生一个中断还是最终都传输完成触发一次中断，刚开始中断处理函数写的程序如下：

void DMA1_Channel2_IRQHandler(void): U2 U( s5 p) D% Z1 B
{
% x) J+ S' \# k8 _5 j% T
uint16_t n = 0;
/ Z4 |7 E: g: c/ P1 O; h0 R+ g+ K
if(DMA_GetFlagStatus(DMA1_FLAG_TC2)) . W5 B( [3 h4 Z! ^+ L9 ]0 J! {
{
) x" @/ q* F! e; z1 ~- G3 Y7 ~
n = ~n;
( W7 Q, p5 ~# ^ D) i k2 q
if(n) LED1(ON);
6 E: f' m/ e+ Y
else LED1(OFF);
7 n+ B( Y, F) y" ` U/ r
DMA_ClearFlag(DMA1_FLAG_TC2); //清除全部中断标志. C4 \3 |" M) r
}
+ r) L5 T5 t+ W" \( i
}

复制代码

通过测试，我发现LED灯并没有像试想的那样每次发送完成后便触发一次中断，然后灯会间隔闪烁，而实际是第一次传输完成后灯点亮，之后就一直保持亮的状态。刚开始我还以为DMA只会触发第一次中断，后来仔细分析后才发现了问题。正确的代码应该如下。

void DMA1_Channel2_IRQHandler(void)) I9 A+ M9 v, B
{
( h. M' o: s4 P* [9 n
static uint16_t n = 0;
' U4 V3 Z' K) B* i$ D
if(DMA_GetFlagStatus(DMA1_FLAG_TC2))
% h/ s( b. U( ^1 i5 I- G
{ ; c( a) {( w( V( G
n = ~n;
. S) H7 L. f# O8 ^7 j P9 i; j$ b
if(n) LED1(ON);, g5 h0 n4 Y8 ]
else LED1(OFF);% O# `% D' Q* ~( ]/ g2 z
DMA_ClearFlag(DMA1_FLAG_TC2); //清除全部中断标志4 y \0 e9 T$ K, m
}7 o) h- E' k+ j+ ^1 T1 ]+ b
}

复制代码

在这里n是一个局部变量，如果不定义成静态变量，每次出中断时后n所占的内存(栈)便会释放，这样再次进入后n还是会初始化为0.与我们要达到的效果不符。因此，在这里我们把它指定为静态变量，那么内存就不会释放，它会保持上一次的的值，修改之后达到了效果，每次传输完成3000个字节后灯的状态就会改变一次。　　

在这里我们整理一下变量：

全局动态变量：作用范围为整个工程，不释放内存，会保持上一次的值。

全局静态变量：作用范围为当前文件，不释放内存，会保持上一次的值。

局部动态变量：作用范围为当前函数，每次函数执行结束释放内存，不会保持上一次的值。

局部静态变量：作用范围为当前函数，不释放内存，会保持上一次的值。

赞收藏评论0 发布时间：2022-1-16 17:43

0个回答

所属标签

STM32G0

【经验分享】stm32之串口通信DMA传输完成中断

所属标签

相似分享

官网相关资源