本篇文章提供两种方法：
一种是 ：IDLE 接收空闲中断+DMA
一种是： IDLE 接收空闲中断+RXNE接收数据中断

+ q- {/ f3 H; W+ n- E" G都可完成串口数据的收发

" k# e' Y& k. m6 F. @# L知识点介绍：
5 D6 A/ h/ q0 I" ]( X( y' cSTM32 IDLE 接收空闲中断
功能：
在使用串口接受字符串时，可以使用空闲中断（IDLEIE置1，即可使能空闲中断），这样在接收完一个字符串，进入空闲状态时（IDLE置1）便会激发一个空闲中断。在中断处理函数，我们可以解析这个字符串。

( a& I& \7 [6 J" A( l: [. G接受完一帧数据，触发中断
. H* }- h  b- p5 Z' k, k- X1 j1 e
: {1 X4 s3 a: L8 g' P9 ^" D3 b/ ~7 y/ QSTM32的IDLE的中断产生条件：
& J; |/ F4 ^/ E" T% q' _4 U8 o在串口无数据接收的情况下，不会产生，当清除IDLE标志位后，必须有接收到第一个数据后，才开始触发，一但接收的数据断流，没有接收到数据，即产生IDLE中断

STM32 RXNE接收数据中断
功能：
$ z& P' z. v( \) S当串口接收到一个bit的数据时，(读取到一个停止位) 便会触发 RXNE接收数据中断
5 p5 R* ~6 Z0 G: U
# g) ~2 E* ?' h接受到一个字节的数据，触发中断
! ?; o) K* p3 |2 F+ g7 Z% A
* @" g$ w' p( g! @+ E1 c比如给上位机给单片机一次性发送了8个字节，就会产生8次RXNE中断，1次IDLE中断。

* P- r5 j. M6 }$ v串口CR1寄存器
+ I# A# h3 e8 h! C' \


对bit4写1开启IDLE接受空闲中断
' n; m: [! T5 W% j7 B9 T$ n,对bit5写1开启RXNE接收数据中断。
: b- A1 ~5 h" x9 [- p5 h
1 W- K# Q4 d7 S6 _' b  r1 Y9 O串口ISR寄存器
( b) l: T# P/ D$ k/ l! C  ^. C
% F  @. F/ [0 y7 s4 M

此寄存器为串口状态查询寄存器

; h- S; |. U& _) M3 x: T6 A/ m当串口接收到数据时，bit5 RXNE就会自动变成1，当接收完一帧数据后，bit4就会变成1.

清除RXNE中断标志位的方法为：

/ Z" T3 H! N% d& \  t" c只要把接收到的一个字节读出来，就会清除这个中断

在STM32F1 /STM32F4 系列中 清除IDLE中断标志位的方法为：
6 r* L: K6 E) }% R! P# h4 ^
1.先读SR寄存器，
2.再读DR寄存器。



; e, e; Q! E7 Amemset()函数

# h% _- ]# M3 p8 a$ o% e. x

1. extern void *memset(void *buffer, int c, int count)        

复制代码

buffer：为指针或是数组
! f9 w  O! g* G8 X( k* f) mc：是赋给buffer的值
count：是buffer的长度.
USART采用DMA接收时，如何读取当前接收字节数？
6 R" `! W+ l. B6 \+ d

1.    #define __HAL_DMA_GET_COUNTER(__HANDLE__) ((__HANDLE__)->Instance->CNDTR);

复制代码

DMA接收时该宏将返回当前接收空间剩余字节
6 t7 f: T! D6 b, ?
实际接受的字节= 预先定义的接收总字节 - __HAL_DMA_GET_COUNTER()
. F# `/ h3 t' K0 J. t8 ]
其本质就是读取NTDR寄存器，DMA通道结构体中定义了NDTR寄存器，读取该寄存器即可得到未传输的数据数呢，
6 f' @# x& G- b0 v; \* s1 p
NTDR寄存器


) j! G$ B- O7 J8 z, D
实现方法：
3 P- z* E8 J" ]' C4 e1 s! _0 {) e5 e两种利用串口IDLE空闲中断的方式接收一帧数据，方法如下:

; l: G& G4 o" l3 {方法1：实现思路：采用STM32F103的串口1，并配置成空闲中断IDLE模式且使能DMA接收，并同时设置接收缓冲区和初始化DMA。那么初始化完成之后，当外部给单片机发送数据的时候，假设这次接受的数据长度是200个字节，那么在单片机接收到一个字节的时候并不会产生串口中断，而是DMA在后台把数据默默地搬运到你指定的缓冲区数组里面。当整帧数据发送完毕之后串口才会产生一次中断，此时可以利用__HAL_DMA_GET_COUNTER(&hdma_usart1_rx);函数计算出当前DMA接收存储空间剩余字节
0 _3 U( E% Y- ]+ Q+ h
$ a3 ?. b3 t( u% a  ?+ g本次的数据接受长度=预先定义的接收总字节-接收存储空间剩余字节
  s2 t6 M- k  X. E) d
比方说 本次串口接受200个字节，

1. HAL_UART_Receive_DMA(&huart1,rx_buffer,200);//打开DMA接收

复制代码

- `- G: d$ [3 L: |然后我发送了 Zxiaoxuan 9个字节的数据长度
. T. H, b* D, _/ Q' i
那么此时 GET_COUNTER函数读出来 接收存储空间剩余字节 就是191个字节

1 Z) F1 V, n* P2 r+ `实际接受的字节(9) = 预先定义的接收总字节(200) - __HAL_DMA_GET_COUNTER()（191）
9 = 200-191

* w, _7 J, C' Z! y. r0 j0 c# p应用对象：适用于各种串口相关的通信协议，如：MODBUS，PPI ；还有类似于GPS数据接收解析，串口WIFI的数据接收等，都是很好的应用对象。

, {& z) A& p& p- o5 s% X0 p6 p) s% o方法2：实现思路：直接利用stm32的RXNE和IDLE中断进行接收不定字节数据。 每次接收到一个字节的数据，触发RXNE中断 将该字节数据存放到数组里，传输完成之后，触发一次IDLE中断，对已经获取到的数据进行处理
$ G3 ^; ^+ k& j# y7 O
例程1
本例程功能：
5 a: }- [: b5 m, O( o7 y
使用DMA+串口接受空闲中断 实现将接收的数据完整发送到上位机的功能
: q' p5 _" f0 V8 |
& @9 C: v1 o/ D/ x9 W( ?
+ z0 B- c9 [" S
" i  t/ b4 c" x/ y. g7 j; o$ F接收数据的流程：
  p) F! v1 N" C. ?$ Q2 m
首先在初始化的时候打开DMA接收，当MCU通过USART接收外部发来的数据时，在进行第①②③步的时候，DMA直接将接收到的数据写入缓存rx_buffer[100] //接收数据缓存数组，程序此时也不会进入接收中断，在软件上无需做任何事情，要在初始化配置的时候设置好配置就可以了。
" r5 p7 l9 |% b2 C5 H. t4 O+ G1 o
数据接收完成的流程：

, y6 `5 y4 v. y% a8 j# C7 L当数据接收完成之后产生接收空闲中断④
  l; i2 `; Q5 ^0 c& ?' [7 R
在中断服务函数中做这几件事：
判断是否为IDLE接受空闲中断
在中断服务函数中将接收完成标志位置1
2 A0 v. n6 q6 K+ X  u关闭DMA防止在处理数据时候接收数据，产生干扰。
计算出接收缓存中的数据长度，清除中断位，
/ s! ?+ ^% O; P! n# j+ n# Z; k* J" h9 u
0 B4 k: q2 Y. \) n6 B2 Q4 {while循环 主程序流程：
主程序中检测到接收完成标志被置1
进入数据处理程序，现将接收完成标志位置0，
1 G/ {9 x6 `7 z: ~! `, a: _) q5 \) H/ |将接收到的数据重新发送到上位机
) D( N" e! P' L8 a9 W重新设置DMA下次要接收的数据字节数，使能DMA进入接收数据状态。

% d  @& G% e( z- A例程代码：
uart.c

1. volatile uint8_t rx_len = 0;  //接收一帧数据的长度
   
2. volatile uint8_t recv_end_flag = 0; //一帧数据接收完成标志
   
3. uint8_t rx_buffer[100]={0};  //接收数据缓存数组

复制代码

1. void MX_USART1_UART_Init(void)
   $ t7 }4 c, k: F( J2 A8 b3 C  q
2. {
   2 H4 ]. ]) z+ V; t4 W
3. 
   3 ?, w8 I" U9 p, |9 B% ~' r3 J4 [
4.   huart1.Instance = USART1;
   * K# o: L7 b2 d: ^6 g2 k2 L
5.   huart1.Init.BaudRate = 115200;
   
6.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   
7.   huart1.Init.StopBits = UART_STOPBITS_1;
   5 a/ {' F& H: T) o) w& |5 g
8.   huart1.Init.Parity = UART_PARITY_NONE;
   # C" U+ n+ |; s9 C, T6 {$ x
9.   huart1.Init.Mode = UART_MODE_TX_RX;
   
10.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    + b8 [7 z* Q- c9 G0 w
11.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    7 Y) I8 v: {9 D* W
12.   if (HAL_UART_Init(&huart1) != HAL_OK)
    0 J3 ~9 [+ a) g/ n# ^8 X
13.   {
    
14.     Error_Handler();
    
15.   }
    
16. //下方为自己添加的代码
    ! u2 J% u3 B6 g& B! B' K! s
17.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
    
18. 
    
19. //DMA接收函数，此句一定要加，不加接收不到第一次传进来的实数据，是空的，且此时接收到的数据长度为缓存器的数据长度
    
20.         HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);
    ; H; \* O: \5 g4 n0 q2 e7 w
21. 
    - _7 x/ W& V) p9 [, z5 t
22.         
    
23. }

复制代码

' C# t$ h8 r. K$ T1 Wuart.h

1. extern UART_HandleTypeDef huart1;
   
2. extern DMA_HandleTypeDef hdma_usart1_rx;
   
3. extern DMA_HandleTypeDef hdma_usart1_tx;
   3 d& q) j$ ~7 {$ T% m
4. /* USER CODE BEGIN Private defines */
   
5. 
   4 z1 X" n6 m% {6 O" q- D2 M
6. 
   
7. #define BUFFER_SIZE  100  
   
8. extern  volatile uint8_t rx_len ;  //接收一帧数据的长度
   
9. extern volatile uint8_t recv_end_flag; //一帧数据接收完成标志
   
10. extern uint8_t rx_buffer[100];  //接收数据缓存数组

复制代码

$ Z2 n5 I2 p( J4 B8 U9 Z9 @4 {" cmain.c
* `; p: `1 b4 G$ b8 Z8 G
7 ?4 n; y8 ^8 f9 H

1. /*
   
2. *********************************************************************************************************
   
3. * 函 数 名: DMA_Usart_Send
   
4. * 功能说明: 串口发送功能函数
   , g% {2 t  m4 r" D; Q% `5 t! T
5. * 形  参: buf，len
   
6. * 返 回 值: 无
   
7. *********************************************************************************************************
   # R* y) M. t+ z' F
8. */
   
9. void DMA_Usart_Send(uint8_t *buf,uint8_t len)//串口发送封装
   - R: `- X$ q' B0 P
10. {
    0 B* x$ z" _  `
11. if(HAL_UART_Transmit_DMA(&huart1, buf,len)!= HAL_OK)   //判断是否发送正常，如果出现异常则进入异常中断函数
    
12.   {
    9 M6 M8 n7 E# e6 f3 e7 k& F6 v
13.    Error_Handler();
    $ p! f7 F# u* |2 t9 R5 ]$ Q
14.   }
    
15. 
    
16. }
    7 e/ D7 F5 d4 w
17. 
    9 {0 O3 d$ z& i
18. 
    , K0 o. m+ u- Z0 Q5 X2 |$ ~
19. 
    ; m- w1 q  z" R1 A1 `8 P  ]5 U+ t
20. /*
    1 j- v6 j3 d' O" Q. c1 m
21. *********************************************************************************************************
    
22. * 函 数 名: DMA_Usart1_Read
    
23. * 功能说明: 串口接收功能函数
    
24. * 形  参: Data,len
    
25. * 返 回 值: 无
    6 A" C: M9 ~5 s7 m9 }1 C8 ~  v
26. *********************************************************************************************************
    & ^; F' i+ d/ k6 L
27. */
    
28. void DMA_Usart1_Read(uint8_t *Data,uint8_t len)//串口接收封装
    
29. {
    7 `' p  ^5 V. T1 ]% B7 a$ l( s- @- `
30.         HAL_UART_Receive_DMA(&huart1,Data,len);//重新打开DMA接收
    
31. }
    

复制代码

- @' h7 U1 Y) [( B, cwhile循环
3 ~& Z4 g$ n/ U+ E: Y

1. while (1)
   
2.   {
   - g- k% M' Q: A$ R" J& ?/ A  A* b
3.     /* USER CODE END WHILE */
   
4. 
   
5.     /* USER CODE BEGIN 3 */
   , q9 J/ Z$ A9 s, D0 K  h0 b" ^7 E
6.                  if(recv_end_flag == 1)  //接收完成标志
   
7.                 {
   0 e0 l- z/ c$ R2 z9 S, H' d
8.                         
   
9.                         
   5 @  C; F, l, @' j' B
10.                         DMA_Usart_Send(rx_buffer, rx_len);
    
11.                         rx_len = 0;//清除计数
    
12.                         recv_end_flag = 0;//清除接收结束标志位
    
13. //                        for(uint8_t i=0;i<rx_len;i++)
    
14. //                                {
    
15. //                                        rx_buffer<i>=0;//清接收缓存</i>
    4 ?+ g7 z+ M1 j; Q% A
16. //                                }
    % A) U( U8 m6 e3 b3 B# N/ E
17.                                 memset(rx_buffer,0,rx_len);
    , O! ]! y3 j9 j- G% s% C( M  x
18.   }
    9 U& S/ i0 C/ p* a. v
19.                 HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);//重新打开DMA接收
    
20. }
    . ]  l8 z  H& y% _% _2 e0 P4 c! ^

复制代码

2 a, h' s9 T  n2 d7 z# `stm32f1xx_it.c中

1. #include "usart.h"
   
2. 
   
3. void USART1_IRQHandler(void)
   ) `& m9 R. T6 i  i
4. {
   
5.         uint32_t tmp_flag = 0;
   
6.         uint32_t temp;
   + i7 l. @+ e/ u4 C& W8 D* p; b3 \
7.         tmp_flag =__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE); //获取IDLE标志位
   8 d7 E/ G8 |. W4 `' R
8.         if((tmp_flag != RESET))//idle标志被置位
   
9.         {
   " U; q) @  H6 Z( C$ b9 @, t
10.                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位
    
11.                 //temp = huart1.Instance->SR;  //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
    
12.                 //temp = huart1.Instance->DR; //读取数据寄存器中的数据
    
13.                 //这两句和上面那句等效
    8 m) D7 r. k" k8 d( Z6 A. U
14.                 HAL_UART_DMAStop(&huart1); //  停止DMA传输，防止
    
15.                 temp  =  __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);// 获取DMA中未传输的数据个数   
    % S6 ?3 H* s# [
16.                 //temp  = hdma_usart1_rx.Instance->NDTR;// 读取NDTR寄存器，获取DMA中未传输的数据个数，
    0 u1 R  [- n# a3 g; I/ j: D) u" F
17.                 rx_len =  BUFFER_SIZE - temp; //总计数减去未传输的数据个数，得到已经接收的数据个数
    ) t3 ^, \- Y1 `
18.                 recv_end_flag = 1;        // 接受完成标志位置1        
    $ F2 I( z# m( n1 t, s3 W
19.          }
    
20.   HAL_UART_IRQHandler(&huart1);
    ) K8 r  {6 D  o( R) G  O/ |
21. 
    4 v3 [" e! S2 X+ o9 o2 ?
22. }
    3 `! o, ^* g( E3 \( i. z2 R

复制代码

7 k# X0 d" W9 Y' g" S8 h注释详解：
  L6 @; N$ d) T" i3 z注释1：

1. temp = UartHandle.Instance->SR;  //清除状态寄存器SR,读取SR寄存器可以实现清除SR寄存器的功能
   ' D# `7 s- P; y$ I+ |; t
2. temp = UartHandle.Instance->DR; //读取数据寄存器中的数据

复制代码

1 A7 F$ z0 S, c1 t' m6 h! a这两句被屏蔽的原因是它们实现的功能和这下面串口IDLE状态寄存器SR标志位清零的宏定义实现的功能是一样的：
! u, e# U1 }( @8 i: Q. `+ g8 J
* I0 u$ J6 u" S0 u7 C; W, `__HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位

/ K; ^- C6 Z& d/ k% O6 I; f6 B我们可以点击这个宏定义进去看看，它实现的功能和上面两句是一样的：
+ S8 M. g4 o# E
" q6 Z1 a" i* i  n#define __HAL_UART_CLEAR_IDLEFLAG(HANDLE) __HAL_UART_CLEAR_PEFLAG(HANDLE)
) W) V" y. k5 A, T! o- M
: C+ D" r6 _$ ]0 c/ R
- z/ \7 Z, U5 m
注释2：

, Y) I6 H$ Z: ]

1. temp  = hdma_usart1_rx.Instance->NDTR;// 获取DMA中未传输的数据个数，NDTR寄存器分析见下面  

复制代码

同理， 这句被屏蔽的原因是因为他和上面的__HAL_DMA_GET_COUNTER的作用也是一样的，都可以获取DMA中未传输的数据个数
6 w! O, R; U, i1 \


测试正常：


! T' K7 w* d  b8 O
, D, Z# B! o( U4 ]此程序可以进行接收不定长的数据帧，不需像RXNE每次接收到一个字节就进一次中断。
同时开启DMA传输速率也会加快
例程2
UART中断使能函数

1. __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)

复制代码

功能： 该函数的作用是使能对应的UART中断

6 M# l+ I) _  ~+ B! [) n( B在stm32f1xx_hal_uart.h中被宏定义
7 K( E% G9 o: `+ f


可以使能的中断一共有这些：
) {6 T+ X9 [$ v$ C6 t3 e5 y% }

$ R$ O# K4 O0 e% U5 `
我们现在所用到的为：

1.   *  @arg UART_IT_RXNE: Receive Data register not empty interrupt
   # l3 b; }3 v. m
2.   *  @arg UART_IT_IDLE: Idle line detection interrupt

复制代码

+ b3 O, F1 Z4 R/ E) `( j: Q7 {RXNE接收数据中断
+ @, M7 U: y" z6 R# jIDLE 接收空闲中断
! Z# j9 |- V) s: Z7 h! s6 x  z
0 b; O. V- [6 b- _( B0 H/ W1 t9 ]

本例程功能：
' S# v- a5 V' d  c( A. c$ m
( h. l) f0 h' t1 Y' N2 b" P5 F. A使用RXNE接收数据中断+IDLE串口接受空闲中断 实现将接收的数据完整发送到上位机的功能
7 C7 v) x: J  _% U" c! }* z4 x
接收数据的流程：

6 l% G+ a+ d  M  J首先在初始化的时候打开DMA接收，当MCU通过USART接收外部发来的数据时，在进行第①②③步的时候，DMA直接将接收到的数据写入缓存rx_buffer[100] //接收数据缓存数组，同样初始化配置的时候设置好配置就可以了。
. K- A; }& U0 \" @3 W! B
接收到一个字节数据：
* j6 p! }5 t) o- T5 J7 u! g接收到一个字节的数据之后，便会进入RXNE接收数据中断，

接受完一帧数据之后，便会进入IDLE 接收空闲中断

在uart.c中添加中断函数

1. void MX_USART1_UART_Init(void)
   
2. {
   . A1 W2 m/ e, h4 b! D6 g  T+ T
3. 
   + g$ A# b1 {/ y; R
4.   huart1.Instance = USART1;
   
5.   huart1.Init.BaudRate = 115200;
   
6.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   
7.   huart1.Init.StopBits = UART_STOPBITS_1;
   6 R* Q! l' u% ]9 y3 k5 Q# {0 c" s
8.   huart1.Init.Parity = UART_PARITY_NONE;
   $ t( o1 P5 \8 j+ Z& X- h8 Z0 y
9.   huart1.Init.Mode = UART_MODE_TX_RX;
   
10.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
11.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
12.   if (HAL_UART_Init(&huart1) != HAL_OK)
    ' k4 k3 A" x. ^+ v* U" U8 S, K' l$ d
13.   {
    
14.     Error_Handler();
    
15.   }
      j- x# w* x0 K& o1 L) Z
16. 
    
17.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE); //使能IDLE中断
    : M3 L& m5 H% f2 \. x" e+ }8 [
18.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); //使能IDLE中断
    % C- i9 d7 H* T- m; W
19. 
    : r, M' [6 V2 y4 y
20. //DMA接收函数，此句一定要加，不加接收不到第一次传进来的实数据，是空的，且此时接收到的数据长度为缓存器的数据长度
    
21.         HAL_UART_Receive_DMA(&huart1,rx_buffer,BUFFER_SIZE);
    
22. 
    * `% k9 `# k8 z9 g, y
23.         
    % l+ ]  d  b' Y7 x; I) z
24. }
    

复制代码

其核心代码就是下面的两句
, X) K' I. q& C; k- H4 y6 [+ h2 g


# Y0 f/ w6 D0 v第一条语句用来判断是否接收到1个字节，第二条语句用来判断是否接收到1帧数据
; H9 l7 v, ?5 Z

1. 
   
2.         if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)  //如果接收到了一个字节的数据
   , I/ S( o0 `4 B( X+ D1 }' X0 q# Y
3.         {
   
4.                         HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_5);    //反转LED
   
5.         }
   
6.         
   2 o6 |* ~  D4 V5 I+ |& H
7.         if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!= RESET)//如果接受到了一帧数据
   2 i, @) V5 `- d( t1 A% h6 A6 F
8.         {
   ( n7 S  |; L9 `1 d' _* L
9.                 __HAL_UART_CLEAR_IDLEFLAG(&huart1);//清除标志位

复制代码

8 h& x# N# y0 M9 b+ j其余部分于上方例程1基本相同
4 Y" r7 L% |, {" I- ^# p
本次测试是检测接收到一个字节就反转LED
经测试，历程正常：

& i* H6 J6 w. W
1 }  U) d) {2 ]: j) s7 U: k7 G


/ x- a( `! y/ c# q