STM32串口空闲中断接收数据的流程：
2 j, m* N6 q: D! U# l3 p

串口接收DMA在初始化的时候就处于开启状态，一直等待数据的到来，在软件上无需做任何事情，只要在初始化配置的时候设置好配置就可以了。

( |2 b& H1 N8 G3 K# r判断数据数据接收完成：

8 T2 s3 p* Q1 Y$ ]9 Z8 z, F这里判断接收完成是通过串口空闲中断的方式实现，即当串口数据流停止后，就会产生IDLE中断。这个中断里面做如下几件事：

• 关闭串口接收DMA通道，2点原因：a.防止后面又有数据接收到，产生干扰。b.便于DMA的重新配置赋值，下面第4点。
• 置位接收完成标志位
• 处理接收buffer中数据
• 重新设置DMA下次要接收的数据字节数，注意，这里是给DMA寄存器重新设置接收的计数值，这个数量只能大于或者等于可能接收的字节数，否则当DMA接收计数器递减到0的时候，又会重载这个计数值，重新循环递减计数，所以接收缓冲区的数据则会被覆盖丢失。
• 开启DMA通道，等待下一次的数据接收，注意，对DMA的相关寄存器配置写入，如第4条的写入计数值，必须要在关闭DMA的条件进行，否则操作无效。
  ) G4 ~! O/ U! {/ y8 e' K* G; o说明一下，STM32的IDLE的中断在串口无数据接收的情况下，是不会一直产生的，产生的条件是这样的，当清除IDLE标志位后，必须有接收到第一个数据后，才开始触发，一断接收的数据断流，没有接收到数据，即产生IDLE中断。IDLE位不会再次被置高直到RXNE位被置起（即又检测到一次空闲总线）。RXNE接收中断可以不用开启，减少进中断的次数。
  # d/ w) |6 V1 G7 X' G. {

' M% s/ P2 w* _2 @6 q) y

8 s# D5 G8 R% s9 O% _

1. void My_UART_Init(void)
   
2. {
   ) [% U, k1 f. o2 \$ L0 W3 }
3.     GPIO_InitTypeDef GPIO_InitStruct;
   7 N! C- b/ I- Y" m* B* y6 M7 G' i
4.     USART_InitTypeDef USART_InitStruct;
   
5.     NVIC_InitTypeDef NVIC_InitStruct;
   
6.     DMA_InitTypeDef DMA_InitStruct;
   ; J9 K4 f" p2 R+ g, g1 i
7. 
   
8.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);      // 使能DMA
   ' ~$ X* n, \8 Y( M8 R3 T' {
9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);   // 使能GPIOA
   
10.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);   // 使能时钟 复用USART
    
11. 
    
12.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
    ' X, B& O) j+ Z) s
13.     GPIO_InitStruct.GPIO_Pin = GPIO_Pin_9;
    + y6 w" L3 M, E3 L) v9 h, ~
14.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;
    
15.     GPIO_Init(GPIOA,&GPIO_InitStruct);  //初始化 USART_TX 即 GPIOA.9
    : ]; Z( o+ u4 k- K' @0 J
16. 
    
17.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
18.     GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
    
19.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_10MHz;
    
20.     GPIO_Init(GPIOA,&GPIO_InitStruct);          //初始化 USART_RX 即 GPIOA.10
    & z% j; L0 s2 s* t0 b
21. 
    
22.     USART_InitStruct.USART_BaudRate = 115200;
    
23.     USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
24.     USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
25.     USART_InitStruct.USART_Parity = USART_Parity_No;
    
26.     USART_InitStruct.USART_StopBits = USART_StopBits_1;
    ! n0 r* C) @* P' r
27.     USART_InitStruct.USART_WordLength = USART_WordLength_8b;
    
28.     USART_Init(USART1,&USART_InitStruct);   //初始化 USART
    
29. 
    
30. //  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);  // 开启 USART 接收缓冲区非空中断
    : u3 M: {7 C# u  ]0 v3 B$ Y
31. //  USART_ITConfig(USART1, USART_IT_TXE, ENABLE);   // 开启 USART 发送缓冲区空中断
    
32. 
    
33.     USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);  //开启 USART1 总线空闲中断
    
34.     USART_Cmd(USART1, ENABLE);//使能USART中断
    7 n7 ?* p  B! X% F, ?! G# j
35. 
    ) l" i4 }; }' a% ]9 u
36.     DMA_DeInit(DMA1_Channel5);
    
37.     DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)(&USART1->DR);    //外设--->内存
    2 B* D, ?; }+ G  b
38.     DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)RxBuffer;
    
39.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    
40.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    ! H0 X9 ^$ ~; z" B- P8 q
41.     DMA_InitStruct.DMA_BufferSize = BufferSize;
    : I% h0 x# _2 r9 c
42.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
    
43.     DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
    : t. Y0 C9 k" g# C/ W" u2 F
44.     DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    : S4 p2 L2 z" e6 o6 q6 n! j2 P
45.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    , ~( \- A+ d4 Q+ K( b5 k. W
46.     DMA_InitStruct.DMA_Priority = DMA_Priority_Medium;
    
47.     DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
    1 S) M$ y( _& G4 {7 t* I
48.     DMA_Init(DMA1_Channel5, &DMA_InitStruct);
    ( z7 J8 f* Z/ l( ^8 Y& o) R
49. 
    
50.     DMA_Cmd(DMA1_Channel5, ENABLE);
    
51.     USART_DMACmd(USART1, USART_DMAReq_Rx, ENABLE);              // 使能 USART1接收DMA
    9 u0 A2 i5 `# t# [
52. 
    
53.     NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
    
54.     NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    
55.     NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0x01;   //抢占优先级 2位 00 01 10 11
    
56.     NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0x01;          //响应优先级 2位 00 01 10 11
    * n- w8 v) o/ ]$ w5 }
57.     NVIC_Init(&NVIC_InitStruct);                                //初始化中断
    
58. }

复制代码

& Q. [! f) [* p' T3 c
0 g% k' V; e* b' P& M% h' c8 L

1 N0 E/ b# `+ N* P, J% i
当MCU通过USART接收外部发来的数据时，在进行第①②③步的时候，主程序可以不用管，DMA直接将接收到的数据写入缓存RxBuffer，程序此时也不会进入接收中断，当数据接收完成之后产生接收空闲中断，在中断服务函数中将接收完成标志位置1，计算出接收缓存中的数据长度，清除中断位，失能DMA防止在处理数据时候接收数据。主程序中检测到接收完成标志被置1，进入数据处理程序，现将接收完成标志位置0，重新设置DMA下次要接收的数据字节数，使能DMA进入接收数据状态。

1. void USART1_IRQHandler(void)
   
2. {
   
3.     uint8_t clear = clear;  // 用来消除编译器的“没有用到”的提醒
   ( v$ {/ k$ {8 I( ^8 K
4.     uint8_t data = 0;
   ! t0 q5 l& R- ^0 i$ x; L; t" D
5. 
   4 Y: |1 S! y; q7 }
6.     if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
   
7.     {
   6 z* e. X5 O' S& Y* q0 q
8.         clear = USART1->SR;
   
9.         clear = USART1->DR;
   
10. 
    
11. //      RxCounter = BufferSize - DMA1_Channel5->CNDTR;//缓存中的字节数
    " |% z0 O- D, G+ D2 m
12.         RxCounter = BufferSize - DMA_GetCurrDataCounter(DMA1_Channel5);//缓存中的字节数
    * C7 E2 ~3 c1 G. I6 c
13. 
    - i% J; Q0 i0 E! A0 T
14. //      USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);
    
15. 
    
16.         RxStatus = 1;   //标记接收到一帧
    
17.         USART_ClearITPendingBit(USART1, USART_IT_IDLE); // 清除空闲中断
    # o6 _1 G$ B$ {* L
18. 
    0 C: W, {8 o3 O" U
19.         DMA_Cmd(DMA1_Channel5, DISABLE);                // 停止DMA，清除DMA缓存
    
20.     }
    , ^3 T  o3 L* R% f# a0 S$ ?+ l
21. }
    ! |+ u  |4 _6 f; }% Q2 y# o
22. 
    
23. int main(void)
    , u& M1 p0 Z/ X6 ]/ K* J2 t$ J& `
24. {
    0 I* h& c6 U& |! W2 Y7 v
25.     uint8_t i = 0;
    
26. 
    
27.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);             // 初始化中断优先级分组
    
28. 
    
29.     My_UART_Init();
      Y& K% w0 x/ [
30. 
    , _( g2 |# W; j3 t/ e
31.     while(1)
    0 ~: B2 n$ u8 j9 w: U" d) o
32.     {
    " N* t# w% v6 y( j7 \8 L
33.         if(RxStatus == 1)
    # c! P) @; _* Z+ E3 r/ Y
34.         {
    0 @, x- Q2 S+ A: j6 _5 a
35.             RxStatus = 0;
    + }6 e0 z; z; h2 V2 L0 [
36.             i = 0;
    
37. 
    
38.             while(RxCounter--)
    7 A* x  u3 I: J9 t$ h; {
39.             {
    
40.                 USART_SendData(USART1, RxBuffer[i++]);
    
41.                 while(USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET);
    ) D7 {& m3 \* ~3 R4 O- ?
42.             }
    
43. 
    " }& G2 e, T- }) I' g& Z3 N
44.             memset(RxBuffer, 0, i); // 清除缓存
    
45.             RxCounter = 0;
    
46. 
    " y$ E8 L+ k0 G; \. T8 `. {
47. //          DMA1_Channel5->CNDTR = BufferSize;
    
48.             DMA_SetCurrDataCounter(DMA1_Channel5, BufferSize);
    
49.             DMA_Cmd(DMA1_Channel5, ENABLE);     
    
50.         }
    
51.     }
    1 K% e2 M# G4 r. Z
52. }

复制代码

6 {7 c! @( x3 U" z. Y7 h

DMA介绍DMA的定义

) M- |, A% h  d" A

直接存储器存取（Direct Memory Access，DMA）是计算机科学中的一种内存访问技术。它允许某些电脑内部的硬体子系统（电脑外设），可以独立地直接读写系统存储器，而不需绕道 CPU。在同等程度的CPU负担下，DMA是一种快速的数据传送方式。它允许不同速度的硬件装置来沟通，而不需要依于 CPU的大量中断请求。

; S7 ^' C& |& c7 j! r+ q6 D

DMA有什么用？

# o' B' E+ Q) H4 ]' k# o

直接存储器存取用来提供在外设和存储器之间或者存储器和存储器之间的高速数据传输。无须CPU的干预，通过DMA数据可以快速地移动。这就节省了CPU的资源来做其他操作。

, P$ D/ A" H; P; B5 Q

有多少个DMA资源？
$ a) v5 e' p# V2 a
7 e# ~' @3 u% {2 U5 Y1 n# Z8 e, I

有两个DMA控制器，DMA1有7个通道，DMA2有5个通道。

数据从什么地方送到什么地方?
, C" F, E1 A$ L; j8 a; r

• 外设到SRAM（I2C/UART等获取数据并送入SRAM）；
  SRAM的两个区域之间；
• 外设到外设（ADC读取数据后送到TIM1控制其产生不同的PWM占空比）；
• SRAM到外设（SRAM中预先保存的数据送入DAC产生各种波形）；
  
  ' r$ s( H' j: q$ a; X2 I  }) @3 q

' N( d" |, v% Q6 j
DMA可以传递多少数据？

传统的DMA的概念是用于大批量数据的传输，但是我理解，在STM32中，它的概念被扩展了，也许更多的时候快速是其应用的重点。数据可以从1～65535个。

6 [1 Y3 ^& a5 |" q5 j/ q2 h4 E* B

DMA控制器与仲裁器

7 L# X9 a: o# M1 C8 @" @: n

现在越来越多的单片机采用DMA技术，提供外设和存储器之间或者存储器之间的高速数据传输。当 CPU 初始化这个传输动作，传输动作本身是由 DMA 控制器 来实行和完成。STM32就有一个DMA控制器，它有7个通道，每个通道专门用来管理一个或多个外设对存储器访问的请求，还有一个仲裁器来协调各个DMA请求的优先权。

DMA 控制器和Cortex-M3核共享系统数据总线执行直接存储器数据传输。当CPU和DMA同时访问相同的目标(RAM或外设)时，DMA请求可能会停止 CPU访问系统总线达若干个周期，总线仲裁器执行循环调度，以保证CPU至少可以得到一半的系统总线(存储器或外设)带宽。

8 h( ]% V% X: v6 q. k

在发生一个事件后，外设发送一个请求信号到DMA控制器。DMA控制器根据通道的优先权处理请求。当DMA控制器开始访问外设的时候，DMA控制器立即发送给外设一个应答信号。当从DMA控制器得到应答信号时，外设立即释放它的请求。一旦外设释放了这个请求，DMA控制器同时撤销应答信号。如果发生更多的请求时，外设可以启动下次处理。

代码展示基于HAL库的串口空闲+DMA主要接收代码

下面是头文件

1. #ifndef DMAT_H
   2 W, z- u1 |: P* R  g& o2 r0 T' B
2. #define DMAT_H
   3 W1 v5 J' k4 x% k$ m1 x* z0 K
3. #include "stm32f1xx_hal.h"
   
4. #include "usart.h"
   
5. 
   
6. extern uint8_t usart2_rx_buffer[33];
     a0 l4 |1 V6 h0 h( A
7. extern uint8_t usart3_rx_buffer[25];
   7 W, [! d3 f, j" ], W* X
8. void MyU2Init(void);
   : w2 i6 w+ X- v9 Y1 q
9. void MyU3Init(void);
   
10. void USART2Handle(void);
    5 P+ B0 n+ ^2 Y+ ~$ L* S1 L, I1 t' {5 i& `
11. void USART3Handle(void);
    
12. void MyUsartHandle(UART_HandleTypeDef *HUART);
    
13. #endif

复制代码

下面是源文件

, a6 P, L: O7 J! P, V

1. #include "dmat.h"
   . n: i) @, L; J7 g" I
2. 
     M0 r1 |- S7 j: @
3. uint8_t usart2_rx_buffer[33]={0};
   2 ~+ h0 n; F" d* H
4. uint8_t usart3_rx_buffer[25]={0};
   + y5 M% P8 n" i- E$ |; }
5. 
   
6. float ROLL_ANGLE=0;
   % |9 Y+ I* _+ q" c' G
7. float PITCH_ANGLE=0;
   2 G1 S6 P9 v& w5 L" J
8. float YAW_ANGLE=0;
   
9. void MyU2Init(void)
   
10. {
    
11.         __HAL_UART_CLEAR_IDLEFLAG(&huart2);
    
12.         __HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE);
    8 r9 @% T# o' X4 U% w! _
13.         HAL_UART_Receive_DMA(&huart2,usart2_rx_buffer,33);
    
14. }
    # s. g$ ]4 c7 O$ L
15. 
    
16. void MyU3Init(void)
    
17. {
    + f; a1 a: o+ y; r" x: c+ V$ J8 K
18.         __HAL_UART_CLEAR_IDLEFLAG(&huart3);
    / ^% N8 R2 A' t
19.         __HAL_UART_ENABLE_IT(&huart3,UART_IT_IDLE);
    ) e2 i" A& z' m5 Y# C
20.         HAL_UART_Receive_DMA(&huart3,usart3_rx_buffer,25);
    
21. }
    $ E, W8 F: y! _" _) r
22. //可以在里面加上想要的功能
    
23. //以及数据处理的代码
    5 J5 C" P# p0 ~5 B( c: M! u7 T
24. //这是采用串口+DMA+空闲中断来处理串口接收的数据
    
25. void USART2Handle(void)
    
26. {
    
27.         if(usart2_rx_buffer[0]==0x55&&usart2_rx_buffer[11]==0x55&&usart2_rx_buffer[22]==0x55)
    & W4 I, C, {0 Z; [9 p
28.         {
    + L: T/ ?5 O. G8 E- s  T' q# G! E
29.                 //总共33个字节的数据，每11个字节的数据算一个数据包，三个数据包分别是加速度包，角速度包和角度包
    
30.                 if(usart2_rx_buffer[23]==0x53)
    $ y0 B' u+ `  U# U0 W1 T
31.                 {
    
32.                         //下面的数据是针对角度包来解析的，得到三个角度
    : U4 c1 ?7 ]& w0 }. K- j1 D
33.                         ROLL_ANGLE=((int16_t)(usart2_rx_buffer[25]<<8|usart2_rx_buffer[24]))/32768.0*180;
    
34.                         PITCH_ANGLE=((int16_t)(usart2_rx_buffer[27]<<8|usart2_rx_buffer[26]))/32768.0*180;
    
35.                         YAW_ANGLE=((int16_t)(usart2_rx_buffer[29]<<8|usart2_rx_buffer[28]))/32768.0*180;
    
36.                 }
    
37.         }
      r5 y( k$ G! \+ \9 r
38. }
    
39. void USART3Handle(void)
    
40. {
    
41. }
    8 a' N- g; P: A- p7 ]
42. void MyUsartHandle(UART_HandleTypeDef *HUART)
    
43. {
    
44.          if(HUART==&huart2)
    & Y& D" f* |1 L1 B/ Y
45.         {
    2 P" u: d+ d0 X4 ~" l) U( _8 \
46.                
    
47.         if(__HAL_UART_GET_FLAG(HUART,UART_FLAG_IDLE))
    
48.         {
    ) Q, H& Z; S% L/ ?- e
49.                
    6 \# }+ o9 b  D$ V+ L/ w
50.                 __HAL_UART_CLEAR_IDLEFLAG(HUART);
    
51.                 HAL_UART_DMAStop(HUART);
    * H. X  f$ @' Y, l% [/ z/ h
52.                 USART2Handle();
    3 S( V7 u- I$ W- F  a! m4 F! J- e3 z
53.                 HAL_UART_Receive_DMA(HUART,(uint8_t*) usart2_rx_buffer,33);
    
54.                
    
55.         }
    3 ]7 `# U/ e1 g% L
56.   }
    
57.         else if(HUART==&huart3)
    
58.         {
    
59.                 if(__HAL_UART_GET_FLAG(HUART,UART_FLAG_IDLE))
    ; o! d( t1 g( w7 I2 e4 q2 U
60.         {
    
61.                 __HAL_UART_CLEAR_IDLEFLAG(HUART);
    
62.                 HAL_UART_DMAStop(HUART);
    / G! E' s" A2 z
63.                 USART3Handle();
    
64.                 HAL_UART_Receive_DMA(HUART,(uint8_t*) usart2_rx_buffer,25);
    
65.         }
    
66.         }
    
67. }
    

复制代码

6 J* D; U3 b+ S) t* U
) W7 Y6 n( J8 v4 C# P0 H$ F

已收藏