一、工具介绍
& _( b+ O! k. j3 O9 ^; ^* I由于项目开发原因要用到STM32H7系列的微控制器，为了缩短项目开发周期和提高效率，采用了ST官方的STM32CubeIDE进行开发，这个集成开发环境的特点主要有：1.从硬件电路设计开始为硬件工程师提供的各个管脚IO功能的映射及功能，方便硬件电路的设置与布局；2.可视化的硬件配置使得已经掌握单片机编程的使用者更加高效开发，只需注重于项目或系统自身功能部分的实现即可。
0 g) h1 F2 A: X! Q' V6 B& S但不得顺带提一下该开发平台的不友好性：区别于STM32官方的std标准库，可视化配置采用了ST自主封装的HAL库(或者有的称为LL库)，其初衷是给项目开发者提高效率和节省项目周期的，但是过高的集成度或者封装程度却会使某些底层外设的协同运作中产生干涉或者不兼容的效果，这也是我们老手使用者的一个头疼之处。

: `) J# {+ b# P, ~, [* O二、通信接口的数据接收方式
相信有过单片机、微控制器或者微处理器开发经验的人都知道(以下都简称微控制器吧)，微控制器有各种通信接口，比如说UART、CAN、I2C、SPI、DCMI等等，这些通信接口在通信速度、通信稳定性以及通信底层协议等等上都具有各自的特点以及优缺点。但是说到数据的接收，各种接口往往都有相类似的接收数据的方式，以下主要说其中的三种：1.阻塞方式接收；2.中断方式接收；3.DMA方式接收数据(各别通信接口没有)

4 v1 q7 k% w1 i5 m0 A$ v1.阻塞方式接收
! C% y5 }2 Q  p, _% m& m. N简单来说就是在系统循环里直接轮询数据，以阻塞方式去读取数据，这样一来当数据量或者数据频率过大时，会过多消耗硬件的资源，系统会把过多时间消耗在了数据的接收上。如果此时应用者在使用这个带操作系统的应用时就会傻傻的在那里等待数据的接收，等数据接收完后才能进行下一步操作。

2.中断方式接收
' m( U1 p8 [6 D8 P* n+ _以串口UART为例，微控制器具有其自身的资源调度方案，中断是最简单的一种，在STM32CubeMX配置好串口中断后，开发环境就会生成中断优先级配置函数、中断处理函数UART_IRQHandler(包含标志位判断、标志位清除还有数据的接收或发送)，但是用户还需在系统初始化中开启所需的中断比如说串口接收中断，通过
: ~' w1 x2 C( \4 w__HAL_UART_ENABLE_IT(&huart1，UART_IT_RXNE)开启，开启RXNE中断后，串口每收到一个数据就会进入一次中断，然后在中断处理函数UART_IRQHandler中进行标志位的处理和数据的接收，接收完成后可以跟踪到函数HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)，这一回调函数的作用一般是作一些软标志位的置位，告诉系统你已经Ready了，或者可以类比为操作系统中的异步事件处理。
- T' N1 e5 Y+ C8 Q5 M9 x+ e+ E% s
2 |6 T! \, U( R4 ^3.DMA方式接收
说了这么多，终于要说到本篇的正题了，当如果终端设备要传输过来的数据量过多的时候，采用中断接收的方法就往往不太对用户者友好了，这时，每接收一个字节的数据，就要进入中断函数，然后又是一系列的标志位的处理，数据的接收或者存储，最后再回调，返回系统一个事件，这样一系列频繁的进出中断处理，往往也不太尽如人意阿。那这时，我们就想把这种进出中断的次数进行尽可能的降低，于是就引入了我们的主角，DMA(Directly Memory Access)。DMA控制器接收到DMA请求后，会得到CPU的总线控制权，在数据传输完成后，又会把总线返回给CPU。这样一系列工作下来，便在存储器和外设之间连通了一条数据通道，使系统更加高效了。
; s7 H& l; ~% p& o6 W& }  T
* I% s. @5 y! e' ?三、运用DMA接收和串口空闲中断遇到的问题
8 Q" `& z/ `( i9 `2 {I.在配置完成串口DMA接收以及串口空闲中断后，对蓝牙接收的数据进行接收。
% y3 Q4 F" }+ R  g. a' M4 N

1. static void MX_UART4_Init(void)
   
2. {1
   : ^, T, k# [2 M7 x5 u
3. 
   
4.   /* USER CODE BEGIN UART4_Init 0 */
   
5. 
   
6.   /* USER CODE END UART4_Init 0 */
   . P, g; K& s& O) b/ ]
7. 
   4 |# x' u! G3 q8 M0 x7 [
8.   /* USER CODE BEGIN UART4_Init 1 */
   
9. 
   
10.   /* USER CODE END UART4_Init 1 */
    
11.   huart4.Instance = UART4;
    0 ]- o! L( H. J7 J1 W* h/ E2 s$ m
12.   huart4.Init.BaudRate = 115200;
      H5 ^( w* E. ~( W
13.   huart4.Init.WordLength = UART_WORDLENGTH_8B;
    
14.   huart4.Init.StopBits = UART_STOPBITS_1;
    ) m: r  i4 Q, m2 |/ `8 e, p- Q2 s/ t( o
15.   huart4.Init.Parity = UART_PARITY_NONE;
    # h6 k  Z/ p" M& x. Y
16.   huart4.Init.Mode = UART_MODE_TX_RX;
    # z9 Y5 ~" s/ |( n7 h. y+ y8 v
17.   huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
18.   huart4.Init.OverSampling = UART_OVERSAMPLING_16;
    ' b: `9 p" X" ^  ^7 b0 ~* d  h
19.   huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
20.   huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
    ! _( ^2 q* g! E4 E, x- M/ B
21.   huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
      P0 `* N' V8 t  [
22.   if (HAL_UART_Init(&huart4) != HAL_OK)
    4 c; C/ K, y# C/ a8 O# b
23.   {
    
24.     Error_Handler();
      `$ ?+ `% s  g" D
25.   }
    1 V( o! r& c% _4 A/ m& F
26.   if (HAL_UARTEx_SetTxFifoThreshold(&huart4, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
    
27.   {
    9 N" N/ H. S, I5 q
28.     Error_Handler();
    2 g( t5 T; L( c% @
29.   }
    , H* x% ?# ]3 ?8 ?: {, Z/ f
30.   if (HAL_UARTEx_SetRxFifoThreshold(&huart4, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
    + o) q- x" V% f8 K
31.   {
    
32.     Error_Handler();
    ; A' j" H/ T$ s1 l2 x
33.   }
    
34.   if (HAL_UARTEx_DisableFifoMode(&huart4) != HAL_OK)
    
35.   {
    + I' k; o5 T% c3 X# C8 @: U" G
36.     Error_Handler();
    $ a5 @9 S- W" I0 S% [. `
37.   }
    
38.   /* USER CODE BEGIN UART4_Init 2 */
    
39. //  __HAL_DMA_ENABLE(&hdma_uart4_rx);
    
40.   __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
    , A) f; |% Z9 Y
41.   HAL_UART_Receive_DMA(&huart4,(uint8_t *)skp_data,buffersize);
      \7 h! C/ F1 |+ Q- G: P& z
42.   /* USER CODE END UART4_Init 2 */
      l1 J7 J; H: P7 X+ R! W- r
43. 
    
44. }

复制代码

II.接收完成回调函数的重新编写
7 L$ }7 z) t7 Y' a( F由于STM32的HAL库自生成的中断处理函数UART_IRQHandler()并没有对空闲中断的处理，而需要用户进行自行编写。
- {7 E* s8 U! H$ @8 P由于配置的DMA流模式为单次模式(Normal)，因此需要在每次接收回调函数中后重新开启串口DMA接收。
$ j5 x* w% Z  m' }- F5 I0 _
( F' m8 H/ D* I& Y) X9 l( l, _7 g

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   & k' Q1 q0 d* ]: w
2. {
   
3.         uint32_t tmp;
   
4.         if(UART4 == huart->Instance)
   
5.         {
   
6.                 if((__HAL_UART_GET_FLAG(&huart4,UART_FLAG_IDLE) != RESET))
   3 f% a) O- K& p; o9 I) @
7.                 {
   
8.                         __HAL_UART_CLEAR_IDLEFLAG(&huart4);
   ( Q5 A- N3 m. ]+ ?  E5 C/ z
9.                 tmp = huart4.Instance->ISR;
   6 P( T/ [9 O6 i2 B  y4 E' a2 V3 V
10.                 tmp = huart4.Instance->RDR;
    . Z5 n) K) b+ D6 Q7 w/ E1 @2 E+ J
11.                         HAL_UART_DMAStop(&huart4);
    ; e2 [+ ^4 A; O4 J8 M4 `
12.                         rx_len =  buffersize - __HAL_DMA_GET_COUNTER(&hdma_uart4_rx);
    2 }$ w; ?4 C3 u4 N8 ~5 I: T
13.                         recv_end_flag = 1;
    
14.                          HAL_UART_Receive_DMA(&huart4,(uint8_t *)skp_data,buffersize);
    
15.                 }
    
16. 
    7 }& \" `2 o5 p  _: y
17.         }
    
18. }

复制代码

5 h0 T8 K  [3 {% b) y; x# tIII.函数主体部分
5 Z3 B9 C; P( p! r* A函数主体中用一个标志位来轮询接收完成这一异步事件是否到来，若置位了，则进行进一步处理。这里由于调试还没有成功，因此在接收完成后先把数据从另一个串口转发出去。于是发现数据有错误。经过几天调试，仍然没发现端倪。

) j# ^8 |# X1 Y% g9 S

1. int main(void)
   
2. {
   % `5 Z& p* O6 m* p
3.   /* USER CODE BEGIN 1 */
   
4. 
   
5.   /* USER CODE END 1 */
   0 r1 x. `0 h* Z
6. 
   8 V7 V: e5 e# A$ M3 W( l
7. 
   
8.   /* MCU Configuration--------------------------------------------------------*/
   
9. 
   ' l; D# P; {8 n3 m
10.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    ) o7 w  G7 \( \* `! T
11.   HAL_Init();
    
12. 
    
13.   /* USER CODE BEGIN Init */
    6 |4 b$ f/ o* G% i4 R+ S
14. 
    % o% h- J# n  v6 k. K& p2 X/ {
15.   /* USER CODE END Init */
    " v* R) B9 M" T8 ^0 P6 {7 a
16. 
    5 B& b3 N7 C& w* R1 t8 K* r! J! u
17.   /* Configure the system clock */
    5 i) L5 y( E' M. p& d. P5 |+ r" P
18.   SystemClock_Config();
    
19. 
    3 o- q6 A( m% W9 Q
20.   /* USER CODE BEGIN SysInit */
    
21. 
    
22.   /* USER CODE END SysInit */
    
23. 
    7 R* C( n! s; ~; e9 ^: Y/ e4 j& L
24.   /* Initialize all configured peripherals */
    / C- X7 M) n- f1 g! U* |7 m, \
25.   MX_GPIO_Init();
    " y( U5 S% N  |- L( v
26.   MX_DMA_Init();
    
27.   MX_TIM1_Init();
    * o. X% y! v1 i/ d( H4 E$ S& m" A" b
28.   MX_UART4_Init();
    
29.   MX_USART3_UART_Init();
    8 V& F9 H0 ]# @' J  ?. f
30. 
    / q! j& p! N+ D  j7 q
31.   /* Initialize interrupts */
    
32.   MX_NVIC_Init();
    / _. {9 B" e* A8 Y8 S
33.   /* USER CODE BEGIN 2 */
    / ?$ s+ j* A% {' B9 T% N! i" f
34. //  HAL_TIMEx_PWMN_Start(&htim1,TIM_CHANNEL_1);
    . `3 \' q4 O: V' G- [* J. C# f2 a
35. 
    
36.   /* USER CODE END 2 */
    & y6 V6 S2 H" P$ u! Z% ]
37. 
    ( J7 J" B4 {- P( U2 e
38.   /* Infinite loop */
    7 l3 W, [- |( d; l- Q9 A
39.   /* USER CODE BEGIN WHILE */
    
40.   while (1)
    2 ?& E1 W0 S7 d+ q5 ~4 K# u' h9 z
41.   {
    ! ~  k7 A- @( {+ B% C  M
42.           if(recv_end_flag == 1)
    
43.           {
    
44.                 HAL_UART_Transmit(&huart3,(uint8_t *)skp_data,rx_len,1000);
    
45.                 recv_end_flag = 0;
    
46.                 rx_len = 0;
    
47.                 memset(skp_data,0,rx_len);
    
48.           }
    5 ~9 c0 R, R5 H8 Y  Z6 H9 x" [1 p( _
49.     /* USER CODE END WHILE */
    
50. 
    / w! C; x+ P8 i# X8 j- e* K3 C2 k
51.     /* USER CODE BEGIN 3 */
    8 b5 X% r. \( ^+ [5 J/ G
52.   }
    
53.   /* USER CODE END 3 */
    
54. }

复制代码

2 a( Q. O4 f+ [' K1 O/ x四、DMA循环模式接收
在漫长的调试后，我发现可以将DMA的模式调整为循环模式(Circular)，在这种模式下串口的DMA接收会具有更高的实时性，这时候我们只需定义适当大小的接收缓冲数组，然后每次串口空闲中断下会接收到数据，当数据量大于缓冲数组大小时，数据会从首地址开始重新覆盖，更重要的是，在循环模式下，不用频繁的开启和停止DMA，使整个系统的实时性更好了因此我们可以定义一个静态寻址下标，来接收我们所需的数据，具体代码如下(STM32Cube中串口DMA模式改为Circular)：

1. void UART4_IRQHandler(void)
   0 ^( \* u. w/ u) I
2. {
   
3.   /* USER CODE BEGIN UART4_IRQn 0 */
   + \4 u$ v' w" C$ b( _6 U2 a3 W5 G
4.   UART_IDLEHandler();
   " `5 S, ^+ X6 y( R3 `
5.   /* USER CODE END UART4_IRQn 0 */
   : |( g; |& y  J: X$ `1 N
6.   HAL_UART_IRQHandler(&huart4);
   / e1 L) H  Z2 b/ ~' R
7.   /* USER CODE BEGIN UART4_IRQn 1 */
   ' M& }3 a0 W- l6 V- p2 a
8. 
   
9.   /* USER CODE END UART4_IRQn 1 */
   ! r" H3 u8 i; V
10. }
    
11. 
    , K. {  V4 m/ u
12. /* USER CODE BEGIN 1 */
    ; H! B3 ^; O, g( @
13. static uint8_t CurrentIndex = 0;
    # E* A. ?: Y6 Y$ Z$ D8 ]; _
14. uint8_t RxBuff[BUFFER_SIZE];
    - B9 Y. q. y$ F" C5 W. P5 T9 N( G6 E
15. uint8_t DataBuffer[BUFFER_SIZE];
    
16. volatile uint8_t RxLen;
    / {8 D$ ]! Q1 E! U, m+ T; {6 S9 V7 p
17. volatile uint8_t RxClp=0;
    
18. extern UART_HandleTypeDef huart3;
    
19. void UART_IDLEHandler(void)
    
20. {
    
21.         uint32_t temp;
    % R+ |4 |  F1 M4 B! K
22.         uint8_t Len = 0;
    
23. 
    
24.         if((__HAL_UART_GET_FLAG(&huart4,UART_FLAG_IDLE) != RESET))
    
25.         {
    
26.                 __HAL_UART_CLEAR_IDLEFLAG(&huart4);
    
27.                 temp = huart4.Instance->ISR;
    ) Z# Q. g' p0 @+ g
28.                 temp = huart4.Instance->RDR;
    
29.                 //HAL_UART_DMAStop(&huart4);
    & k* {7 C' d  F% z% ^
30.                 temp = 0;
    5 r/ X# H& @6 X" P* E
31.                 Len =  BUFFER_SIZE - __HAL_DMA_GET_COUNTER(&hdma_uart4_rx);
    , F, o3 J, F9 V
32.                 while(CurrentIndex != Len)
    3 b8 n' A" k9 e; L. k
33.                 {
    
34.                         DataBuffer[temp++] = RxBuff[CurrentIndex++];
    
35.                         if(CurrentIndex >= BUFFER_SIZE)
    & M: I8 s! b! W2 ?; K) X
36.                                 CurrentIndex = 0;
    
37.                 }
    % O- r, z) ]5 U* r7 h* i
38.                 RxLen = temp;
    & \! @# Z0 B+ W; T
39.                 HAL_GPIO_TogglePin(LED_GPIO_Port,LED_Pin);
    
40.                 HAL_UART_Transmit(&huart3,(uint8_t *)DataBuffer,(uint16_t)RxLen,100);
    ' i  V5 G. @3 N0 m: T. N
41.                 //HAL_UART_Receive_DMA(&huart4,(uint8_t *)RxBuff,BUFFER_SIZE);
    
42.         }
    $ F; B9 W2 W; F7 [7 v
43. 
    
44. }

复制代码

' V5 m( U/ K( a" b4 L/ b经过一轮调试后，发现接收的数据还是不对。调试到这里的话，我的思绪已经想不出别的办法了…
顺带描述一下我的系统：我使用的是市面上十分普遍的蓝牙模块HC-05(蓝牙A)，蓝牙A连接到我的传感器，传感器的速率是10Hz，然后通过两个HC-05模块进行配对(即与另一个蓝牙B配对)，而后蓝牙B与我的微控制器STM32H7的串口4(UART4)连接，串口4采用DMA循环模式+空闲中断进行接收并存到数组中，然后通过另一个串口3进行发送数据。
系统运作的描述：系统起电后，蓝牙A与蓝牙B还没配对时，蓝牙A已经能收到传感器数据，而后两个蓝牙配对成功，接下来就运行了我上述调试的代码，后面通过PC串口助手接收串口3数据发现，只能接收到部分帧头0x55或者0xAA，而且没有规律性可言。传感器的数据一帧是固定的8个字节，以0x55为帧头，0xAA为帧尾。
) m3 a: ^3 c0 n  \5 K$ T
五、问题最终解决
1 ]" z( k6 u0 v8 |7 x% k在重新梳理整个系统的时序和逻辑后，发现系统起电后，两个蓝牙需要一定的时间去配对，方可接收传感器的数据，于是在系统初始化阶段加入一段适当的阻塞延时，等待蓝牙配对成功，随后启动传感器数据流模式，最终发现之前的空闲中断与DMA工作正常，维持了一周的Bug，通过逐步细查找出了问题所在：
( h: A$ V! t7 G) U: G4 [* S8 h

1. HAL_Init();
   
2. 
   * ?6 n( ^8 i/ x
3.   /* USER CODE BEGIN Init */
   
4. 
   2 w1 i: V' }, j% U0 q
5.   /* USER CODE END Init */
   
6. 
   
7.   /* Configure the system clock */
   0 ?6 `. Y% W- b7 L$ M; l
8.   SystemClock_Config();
   
9. 
   ; L/ }' ^9 f  H' k4 U+ x
10.   /* USER CODE BEGIN SysInit */
    
11. 
      N  n+ W1 D9 w5 m- q& c) W+ Q; r
12.   /* USER CODE END SysInit */
    ! i  S2 u% A+ ]8 j5 Z* D1 h
13. 
    
14.   /* Initialize all configured peripherals */
    $ N( {  [2 H! T5 ], v: i
15.   MX_GPIO_Init();
    " p- V9 n) Z) E- h$ W3 v# @
16.   MX_DMA_Init();
    
17.   MX_UART4_Init();
    
18.   MX_USART3_UART_Init();
    
19. 
    
20.   /* Initialize interrupts */
    
21.   MX_NVIC_Init();
    # ]% V; O2 x8 g& `. B
22.   /* USER CODE BEGIN 2 */
    
23.   HAL_UART_Receive_DMA(&huart4,rcvData,BUFFERSIZE);
    
24.   __HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE);
    8 d1 ?) U- ]& S
25.   HAL_Delay(1000);
    : i* V/ B+ @9 C; g: J2 C# g
26.   HAL_UART_Transmit(&huart4,startMeasure,8,10);
    . G6 P0 N" i* Q) j
27.   /* USER CODE END 2 */
    $ }- z( {% Q0 ^! Q6 V
28. 
    $ h; k# N- u+ y* A; H5 X/ C! D

复制代码

/ L& Z' Z% |4 E7 r+ H8 x