中断接收方式，最大的缺点就是中断过于频繁，为了解决这个问题那就把DMA搬过来，它不就是专门搬用数据的嘛，不用多可惜。
3 d% a8 l. H" T5 [' s+ G' G  b4 q6 J
. N2 `! d4 f! n# S. a" ^首先我们需要大致了解，DMA和外设传送数据，例如串口，我们希望，当一帧数据接收完毕了，有个东西告诉主程序，串口接收到了一帧n个字节的数据存在某个地方，接收过程中你丫别打搅我。
$ G5 y: \7 z$ p0 |
3 v6 P% k+ O9 \+ Q" zDMA就能胜任这个工作，他可以以中断的形式告诉你这些信息。相比中断接收方式，是不是省了很多中断，主程序被打断的次数也就少了。

0 S; @: c9 c3 R( G% n9 d7 ~2 {0 r还是按照上一篇形式大概看一下，HAL库中DMA是怎么和串口配合的。
+ M" F- k( d/ t

1. /**
   & J7 q0 z6 {. ^8 G
2.   * @brief Receive an amount of data in DMA mode.
   8 c0 P( {* q* N/ k! m7 O' I
3.   * @note   When the UART parity is enabled (PCE = 1), the received data contain
   
4.   *         the parity bit (MSB position).
   , a, c+ u8 _( b. q; D6 l: ]6 i- O! N
5.   * @param huart UART handle.
   ' I. _7 J1 T/ r0 v( }/ h) c9 L! F
6.   * @param pData Pointer to data buffer.
   
7.   * @param Size  Amount of data to be received.
   % o, {1 z; _  l3 K3 f$ i; t
8.   * @retval HAL status
   
9.   */
   & d; S, ^7 |6 T9 J4 W
10. HAL_StatusTypeDef HAL_UART_Receive_DMA(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
    
11. {
    3 O! r) }5 q% I" i* A' \
12.   /* 其他关系不大的代码省略 有兴趣可以自己看 下同 */
    2 G* \6 I7 a1 i( `3 A1 y, |
13.   //1.检查参数 判断串口接收状态为就绪 把缓存区参数传递到串口句柄  修改某些状态
    # g. x5 Z' c& I, |1 B0 Q, \4 X
14.   //2.判断和串口句柄关联的DMA句柄地址不为空  然后给DMA句柄注册一些回调函数
      z! |% t0 I; w4 [4 |$ n
15.       /* Enable the DMA channel */
    & M: w6 G% J- s6 U  t
16.       if (HAL_DMA_Start_IT(huart->hdmarx, (uint32_t)&huart->Instance->RDR, (uint32_t)huart->pRxBuffPtr, Size) != HAL_OK)
    $ E# e# U$ Z5 ]- N2 Z3 w
17.     {
    , B" l6 A. Y0 m5 \" `6 ?0 L* d
18.       ......
    
19.     }
    
20. }

复制代码

HAL_UART_Receive_DMA这个函数里最主要的就是调用了HAL_DMA_Start_IT这个函数，你看他连参数都没怎么变，就把句柄换了，其他三个原封不动的传递过去了。所以函数内其他内容几乎不用考虑了。直接往下看这个函数。

1. /**
   & g5 I! M' G! V1 J5 U; f( t
2.   * @brief  Start the DMA Transfer with interrupt enabled.
   
3.   * @param  hdma:       pointer to a DMA_HandleTypeDef structure that contains
   ' v% ~* ^1 Z! R, m# q
4.   *                     the configuration information for the specified DMA Stream.
   . H6 a" N% x1 m: I
5.   * @param  SrcAddress: The source memory Buffer address
   2 x& e% h( ?0 q- w5 B4 `0 p
6.   * @param  DstAddress: The destination memory Buffer address
   7 ?5 Z  d4 K. h0 a
7.   * @param  DataLength: The length of data to be transferred from source to destination
   9 a" \: B. `2 q! ^# ~6 I
8.   * @retval HAL status
   0 x7 g9 ]$ |/ n6 @+ W# G6 A% c! v
9.   */
   # K! {, h( S0 K. r3 I4 a
10. HAL_StatusTypeDef HAL_DMA_Start_IT(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
    - z9 n8 k2 v% B; l4 V' k4 {( \
11. {
    6 p6 x2 y! w; n, T
12.   //1.检查参数 给句柄上锁 判断状态 只有在就绪状态下才允许配置
    
13.   //2.判断就绪状态
    
14.   {
    6 |9 Q9 e4 Z/ H
15.     ......
    
16.     /* Configure the source, destination address and the data length */
    
17.     DMA_SetConfig(hdma, SrcAddress, DstAddress, DataLength);
    
18.     ......
    
19.     //这里会开启一堆中断  完事要用  暂时可以不关心
    9 D) f' D: M0 o- J4 x. T
20.   }
    
21. }

复制代码

+ k+ r) ]1 f3 T* G$ m$ j8 O上面这个函数也差不多还是那个意思，都懒的看了，主要是调用了DMA_SetConfig这个函数，追踪过去，它才是真正配置寄存器的函数，HAL库就是这么繁琐。

! Y, S: Y; g+ i/ x

1. /**
   & ?3 \* k8 r! }8 `- s5 ]9 A2 `. u
2.   * @brief  Sets the DMA Transfer parameter.
   
3.   * @param  hdma:       pointer to a DMA_HandleTypeDef structure that contains
   2 s6 Q& t/ [' E
4.   *                     the configuration information for the specified DMA Stream.
   7 P- K7 \4 j9 O  T
5.   * @param  SrcAddress: The source memory Buffer address
   / J; v% J0 `0 [; m' `) l- w
6.   * @param  DstAddress: The destination memory Buffer address
   + X; W' S( _3 g% j8 w
7.   * @param  DataLength: The length of data to be transferred from source to destination
   
8.   * @retval None
   2 e0 ]" t$ i: X+ C9 s2 z3 D
9.   */
   
10. static void DMA_SetConfig(DMA_HandleTypeDef *hdma, uint32_t SrcAddress, uint32_t DstAddress, uint32_t DataLength)
    
11. {
    
12.   /* calculate DMA base and stream number */
    4 Z) k! ~8 U6 F" [. i7 i. h
13.   //获取DMA控制器对应流的基地址
    
14.   DMA_Base_Registers  *regs_dma  = (DMA_Base_Registers *)hdma->StreamBaseAddress;
    
15.   BDMA_Base_Registers *regs_bdma = (BDMA_Base_Registers *)hdma->StreamBaseAddress;
    - C8 E5 i2 _8 p
16. 
    
17.   /* Clear the DMAMUX synchro overrun flag */
    : ^3 I; V* Z5 K+ A7 {
18.   hdma->DMAmuxChannelStatus->CFR = hdma->DMAmuxChannelStatusMask;
    . @2 y. L1 i$ {$ G
19. 
    
20.   if(hdma->DMAmuxRequestGen != 0U)
    
21.   {
    & A) R2 M- |% G
22.     /* Clear the DMAMUX request generator overrun flag */
    
23.     hdma->DMAmuxRequestGenStatus->RGCFR = hdma->DMAmuxRequestGenStatusMask;
    ' E0 d0 U+ Q. @/ v4 H5 ~0 s
24.   }
    
25. 
    
26.   if(IS_DMA_STREAM_INSTANCE(hdma->Instance) != 0U) /* DMA1 or DMA2 instance */
    
27.   {
    
28.     /* Clear all interrupt flags at correct offset within the register */
    
29.     regs_dma->IFCR = 0x3FUL << (hdma->StreamIndex & 0x1FU);
    
30. 
    
31.     /* Clear DBM bit */
    
32.     ((DMA_Stream_TypeDef *)hdma->Instance)->CR &= (uint32_t)(~DMA_SxCR_DBM);
    
33. 
    ! N0 Z: u7 D' }  `6 X
34.     /* Configure DMA Stream data length */
    
35.     //这里设置搬用的目标数据长度
    # g$ L4 S$ S. [3 D2 Q
36.     ((DMA_Stream_TypeDef *)hdma->Instance)->NDTR = DataLength;
    
37. 
    
38.     /* Peripheral to Memory */
    
39.     //整个这个if判断是在设置DMA搬运数据的目标地址和源地址
    
40.     if((hdma->Init.Direction) == DMA_MEMORY_TO_PERIPH)
    + i& o6 B/ [. L! U6 J0 j
41.     {
    
42.       /* Configure DMA Stream destination address */
    4 [5 a. i, D; O9 w1 L- p
43.       ((DMA_Stream_TypeDef *)hdma->Instance)->PAR = DstAddress;
    
44. 
    
45.       /* Configure DMA Stream source address */
    7 A9 i9 B% b' b7 H  S
46.       ((DMA_Stream_TypeDef *)hdma->Instance)->M0AR = SrcAddress;
    7 I- m& }+ a3 t$ Y
47.     }
    
48.     /* Memory to Peripheral */
    
49.     else
    5 U+ U, h1 l* [% B+ X- y) v( q  P" _
50.     {
    
51.       /* Configure DMA Stream source address */
    / \2 u6 {4 g+ b0 e2 _' f4 j
52.       ((DMA_Stream_TypeDef *)hdma->Instance)->PAR = SrcAddress;
    7 P0 e" r) {8 D  n. F2 j0 [2 x" U
53. 
    & u+ q7 ^/ e1 [
54.       /* Configure DMA Stream destination address */
    ' L+ i. y0 k- x$ O! L4 ?/ Y
55.       ((DMA_Stream_TypeDef *)hdma->Instance)->M0AR = DstAddress;
    
56.     }
    + w* M2 A1 @6 t) P* W. E5 v
57.   }
    ) T* v, C2 S/ {$ ~3 p* o0 @% f
58.   else if(IS_BDMA_CHANNEL_INSTANCE(hdma->Instance) != 0U) /* BDMA instance(s) */
    
59.   {
    ! z' H' |+ }; k4 l5 c( Y
60.     /* Clear all flags */
    ' R$ i, M3 F4 Z9 D3 t  L: M
61.     regs_bdma->IFCR = (BDMA_ISR_GIF0) << (hdma->StreamIndex & 0x1FU);
    / u5 `4 |$ S% z' C
62. 
    % q3 V6 H) L9 W# w0 m3 g6 \
63.     /* Configure DMA Channel data length */
    
64.     ((BDMA_Channel_TypeDef *)hdma->Instance)->CNDTR = DataLength;
    
65. 
    ! u, b  U* J- B; v
66.     /* Peripheral to Memory */
    , Y- @: ]7 e/ K1 e' |
67.     if((hdma->Init.Direction) == DMA_MEMORY_TO_PERIPH)
    2 n8 y) c' g# o* a0 U8 u- o6 t" c
68.     {
    % m! s4 c$ E$ {8 Q
69.       /* Configure DMA Channel destination address */
    + V% l* G  ~% y, F0 {  h/ u" `' y
70.       ((BDMA_Channel_TypeDef *)hdma->Instance)->CPAR = DstAddress;
    5 q: d! T$ O) Z- n8 ]
71. 
    + I9 _2 y/ ~+ |! M
72.       /* Configure DMA Channel source address */
    
73.       ((BDMA_Channel_TypeDef *)hdma->Instance)->CM0AR = SrcAddress;
      P: u. b/ u$ M( m! g% k
74.     }
    - f* x/ E" t' [
75.     /* Memory to Peripheral */
    
76.     else
    
77.     {
    ; J" V" U/ C% q, ~5 b6 Z
78.       /* Configure DMA Channel source address */
    9 A) X; ?0 B1 i) K5 l6 Y
79.       ((BDMA_Channel_TypeDef *)hdma->Instance)->CPAR = SrcAddress;
    
80. 
    ( Q5 |8 d# J( A! j. A5 h
81.       /* Configure DMA Channel destination address */
    
82.       ((BDMA_Channel_TypeDef *)hdma->Instance)->CM0AR = DstAddress;
    ( {' H" z+ x, {7 t& G0 M& T! W
83.     }
    3 p/ a4 o6 n$ ]6 L
84.   }
    6 m% M$ D. R- R
85.   else
    
86.   {
    ' Y4 I$ h. `( U% S- [$ D0 t: n+ s' `
87.     /* Nothing To Do */
    
88.   }  
    
89. }

复制代码

& h3 a8 _, c/ E/ M' e各位同志你们自己看吧这个函数最主要的目的就是配置DMA寄存器。以上就是串口DMA接收函数中最重要的部分。好像没什么意义一样，因为我要用到其中的一点点东西，所以必须要分析源码。

我们只是说了调用接收函数，参数里边指定了接收缓存，也指定了大小，似乎和我们的目标不符合，假设我们的DMA和串口之间的配置已经配置好了，那现在能做到的就是把数据收集到这个缓冲区里，可是并不能告诉主程序接收到了数据，和接收了多少，想要知道这个，有两种方法，一种是CPU定时去问DMA接收了多少数据，然后自己定义一个记录变化的变量，配合，另一种是中断方式，我们通过查询得知，DMA只有接收完成和接收半完成两个中断。
* ^: ~2 z! g0 g/ v
最最主要的串口的空闲中断不要忘了呀，这个可以告诉你，一帧数据接收完了，你可以根据这个中断去搞，接收了多少，在什么地方。
) {4 e0 a2 y/ V0 m6 G# P* G
因为这个编辑器不知道咋回事，贴代码总是挂，上边那个函数就贴了我很长时间，很生气，所以我就无耻的把源码整到这里了，整个工程哦（暂时还没有上传）。

再试试贴代码吧，方便你我他，要积分的都无耻。改天
; ~  `# P6 [' p
uart.c文件就这么多代码，

+ m) Y5 _# I7 ?; k4 y

1. #include "Uart.h"
   9 G: d" W9 _9 p1 {
2. #include "stm32h7xx_hal.h"
   $ w9 G% E4 ?- j9 ~! l8 }
3. 
   ! V3 h3 U9 J  {
4. #define RxBufSize   1024
   
5. 
   $ O6 h1 H+ p0 {6 Y
6. UART_HandleTypeDef hUart1 = {0};
   
7. DMA_HandleTypeDef hDmaUart1Tx = {0};
   
8. DMA_HandleTypeDef hDmaUart1Rx = {0};
   
9. 
   
10. //数组后边的那个限定跟你的内存分配有关 如果你的主RAM在512K的那个片内存就可以不加 这是AC6编译器用法
    1 n- G5 }/ A( K3 D
11. uint8_t RxBuf[2][RxBufSize] __attribute__((section (".RAM_D1")));
    ! A5 [" [. Q$ c' s7 E
12. void (*Uart1RxCompleteCallback)(uint8_t *pData,uint16_t *Count);
    + y4 t# n  H, ~1 K& @& ^& s
13. 
    
14. void Uart1Init(uint32_t BaudRate,void (*RxCompleteCallback)(uint8_t *pData,uint16_t *Count))
    % T6 T7 I( K  }+ Q. e/ u+ |
15. {
    
16. hUart1.Instance = USART1;
    + S' h7 Z# [. E5 R' U; Y/ R
17. hUart1.Init.BaudRate = BaudRate;
      E/ Z* o+ w) U. o% G& S7 c" j1 W9 k  N
18. hUart1.Init.ClockPrescaler = UART_PRESCALER_DIV2;
    4 `  t3 \$ w; k1 G4 v) f3 L
19. hUart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    1 [6 I0 P$ B" [0 h
20. hUart1.Init.Mode = UART_MODE_TX_RX;
    % f5 j- S; m! w6 Q
21. hUart1.Init.OneBitSampling = UART_ONEBIT_SAMPLING_DISABLED;
    5 h& y3 `, E# j
22. hUart1.Init.OverSampling = UART_OVERSAMPLING_8;
    1 f: P# ^3 w) Y' s
23. hUart1.Init.Parity = UART_PARITY_NONE;
    % K) h$ v- R5 g3 f5 d4 |
24. hUart1.Init.StopBits = UART_STOPBITS_1;
    " Y( \( R$ m3 v! C2 f# Y
25. hUart1.Init.WordLength = UART_WORDLENGTH_8B;
    : U# L  g1 c7 D# {0 i
26. hUart1.FifoMode = UART_FIFOMODE_DISABLE;
    
27. 
    * t# d' `  O  {" x3 `3 Q* O3 q% H
28. HAL_UART_Init(&hUart1);
    / M7 {5 H0 O% s) L; V
29. 
    4 _9 u5 z6 P- L
30. __HAL_RCC_DMA1_CLK_ENABLE();
    , f; F- Z4 i/ e- i
31. 
    : k" K- ?  ]3 y3 X7 t
32. hDmaUart1Tx.Instance = DMA1_Stream0;
    
33. hDmaUart1Tx.Init.Request = DMA_REQUEST_USART1_TX;
    # \0 H1 [4 L. A
34. hDmaUart1Tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
    5 |- v  ]: M2 n
35. hDmaUart1Tx.Init.PeriphInc = DMA_PINC_DISABLE;
    
36. hDmaUart1Tx.Init.MemInc = DMA_MINC_ENABLE;
    
37. hDmaUart1Tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    ! {8 v' w8 q* ]# x/ [0 W
38. hDmaUart1Tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    1 y, s' u6 I0 A/ Q7 ^* ^
39. hDmaUart1Tx.Init.Mode = DMA_NORMAL;
    " c2 Z/ S$ K" f9 q% j6 b
40. hDmaUart1Tx.Init.Priority = DMA_PRIORITY_MEDIUM;
    
41. 
    
42. HAL_DMA_Init(&hDmaUart1Tx);
    
43. __HAL_LINKDMA(&hUart1,hdmatx,hDmaUart1Tx);
    3 s" ]# E- _& U
44. 
    
45. hDmaUart1Rx.Instance = DMA1_Stream1;
    
46. hDmaUart1Rx.Init.Request = DMA_REQUEST_USART1_RX;
    
47. hDmaUart1Rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    
48. hDmaUart1Rx.Init.PeriphInc = DMA_PINC_DISABLE;
    
49. hDmaUart1Rx.Init.MemInc = DMA_MINC_ENABLE;
    
50. hDmaUart1Rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    
51. hDmaUart1Rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    2 T9 s) }3 X% h4 P, h! r& C
52. hDmaUart1Rx.Init.Mode = DMA_NORMAL;
    
53. hDmaUart1Rx.Init.Priority = DMA_PRIORITY_MEDIUM;
    
54. 
    # ?' e/ r. s  D
55. HAL_DMA_Init(&hDmaUart1Rx);
    1 L0 P9 S. S) e0 O/ G, E
56. __HAL_LINKDMA(&hUart1,hdmarx,hDmaUart1Rx);
    ( W+ s  d0 T( a
57. 
    
58. HAL_UART_Receive_DMA(&hUart1,RxBuf[0],RxBufSize);
    . E" |8 `2 y9 \: {" N0 [! h: d8 y
59. 
    . K; @; @; J& }0 E* d
60. __HAL_UART_ENABLE_IT(&hUart1,UART_IT_IDLE);
    ! a; k. `$ W. f9 I3 Y! l) c# ~
61. HAL_NVIC_EnableIRQ(USART1_IRQn);
    
62. HAL_NVIC_SetPriority(USART1_IRQn,14,0);
    
63. 
    
64. HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);//Tx
    ! ?/ m( e8 M' _9 q2 f& |
65. HAL_NVIC_SetPriority(DMA1_Stream0_IRQn,14,0);
    6 ?* V3 y2 d$ J. ~' \
66. 
    
67. HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);//Rx
    
68. HAL_NVIC_SetPriority(DMA1_Stream1_IRQn,14,0);
    & x- }/ B9 Y# m2 \' B8 \
69. 
    
70. Uart1RxCompleteCallback = RxCompleteCallback;
      f8 y% ~9 {3 S4 _: q+ ?# O
71. }
    
72. 
    ) W/ e( v/ T, X; c2 d" d8 P
73. void HAL_UART_MspInit(UART_HandleTypeDef *huart)
    
74. {
    * n. V! x+ j* r2 F: e
75. if(huart == &hUart1)//串口1
    
76. {
    2 J$ L1 h' V* f2 N' K+ r; g: b& y
77.   GPIO_InitTypeDef GPIO_InitStruct;
    
78. 
    % p* q- G6 p* @8 M# G2 H# m! `8 e
79.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    
80.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    + z& K" u# @& H+ k
81.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
    2 _9 C( D" z9 ?' p  S* |
82.   GPIO_InitStruct.Alternate = GPIO_AF7_USART1;
    6 f" r' P0 m/ H, ]7 [$ c
83.   GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_9;
    
84. 
    
85.   __HAL_RCC_GPIOA_CLK_ENABLE();
    ( C9 Q( d, H  e9 z* l; G
86.   __HAL_RCC_USART1_CLK_ENABLE();
    ) V. P' F% C. O0 Q8 j- F
87. 
    
88.   HAL_GPIO_Init(GPIOA,&GPIO_InitStruct);
    * x2 k2 J; _# x3 H1 z4 M5 d
89. }
    
90. }
    
91. 
    $ e! [2 N! m; N1 x% c
92. void Uart1TxData(uint8_t *pData,uint16_t Count)
    
93. {
    % h9 ^/ k4 j& t" o
94. if(Count)
    9 E. I. v+ E; s) n
95.   HAL_UART_Transmit_DMA(&hUart1,pData,Count);
    
96. }
    
97. 
    
98. void USART1_IRQHandler(void)
      l% H3 I3 K& `( J4 B; N
99. {
    
100. if(__HAL_UART_GET_FLAG(&hUart1,UART_FLAG_IDLE))
     $ p* j9 J3 q! O  m! Y1 O. |' a
101. {
     
102.   static uint16_t count;
     : z1 z5 Z! X( U$ R. S- t. F7 D
103.   __HAL_UART_CLEAR_IDLEFLAG(&hUart1);
     
104.   if(Uart1RxCompleteCallback)
     0 \& H; _- `, U
105.   {
     9 M% e" c" K3 B
106.    hUart1.RxState = HAL_UART_STATE_READY;
     
107.    hDmaUart1Rx.State = HAL_DMA_STATE_READY;
     
108.    HAL_UART_RxCpltCallback(&hUart1);
     8 {4 d: f3 ~" t% p% m; R; S
109.   }
     # z1 z$ g. [; K- y0 m, n
110. }
     ; H  t0 O5 k" k; {  N
111. else
     ' C* }4 C4 |- V+ Z$ P* r) x  s) P
112.   HAL_UART_IRQHandler(&hUart1);
     : I, X; s' b# d+ Z4 v
113. }
     ' i& j2 h  ]3 g' h) V( d, |
114. 
     - m( h* c/ I: i& h2 I
115. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
     / q- |9 \$ J- M3 ^9 i: e
116. {
     ) A6 Q  b; A: \. a; b
117. if(huart == &hUart1)
     $ E5 I3 o# |8 Q( `! @" E6 k
118. {
     ; w0 t" u1 U3 ?' y3 B: q. p1 w
119.   static uint16_t count;
     ( ?& ]- i+ Y3 M7 I5 c
120.   count = RxBufSize - __HAL_DMA_GET_COUNTER(&hDmaUart1Rx);
     # M* m; ]* x3 _0 e7 @# l* g  U4 O7 L
121.   if(count == 0)return;
     & ^+ J$ G( R& `
122.   hDmaUart1Rx.Lock = HAL_UNLOCKED;
     
123.   if(huart->pRxBuffPtr < RxBuf[1])
     
124.   {
     
125.    Uart1RxCompleteCallback(RxBuf[0],&count);
     
126.    HAL_UART_Receive_DMA(&hUart1,RxBuf[1],RxBufSize);
     3 H5 A& C* m( R% j- E* q& r2 @; v
127.   }
     8 t7 f  a3 j0 Z/ M
128.   else
     
129.   {
     + s  ]# h; Z6 s- H3 M
130.    Uart1RxCompleteCallback(RxBuf[1],&count);
     
131.    HAL_UART_Receive_DMA(&hUart1,RxBuf[0],RxBufSize);
     / c& E+ h* b- Y8 z. Q: o
132.   }
     
133.   hDmaUart1Rx.Lock = HAL_LOCKED;
     
134. }
     
135. }
     
136. 
     ' v: K2 x6 q8 j7 N2 }. m; T
137. void DMA1_Stream0_IRQHandler(void)
     % y3 Q' G; h! k  Y. t
138. {
     
139. HAL_DMA_IRQHandler(&hDmaUart1Tx);
     5 U& z8 ~, k* H1 k" J) L
140. }
     " A5 K, D, n4 z, _
141. 
     
142. void DMA1_Stream1_IRQHandler(void)
     
143. {
     . H) H" T; P+ Y8 o3 d: s+ m% D$ s
144. HAL_DMA_IRQHandler(&hDmaUart1Rx);
     
145. }

复制代码

这个是Uart.h文件
7 K& m  E7 s: Y& f4 _; k* G' P
$ r" ?, m3 S6 D! w

1. #ifndef __Uart_H_
   0 Q* Q7 [( N  g' g
2. #define __Uart_H_
   ( v* f2 r$ A3 _( \
3. 
   
4. #include "stdint.h"
   3 u4 d6 I1 j' A: Y! D8 D
5. 
   6 z( q% ~9 C+ S1 q: S# h
6. void Uart1Init(uint32_t BaudRate,void (*RxCompleteCallback)(uint8_t *pData,uint16_t *Count));
   3 b8 {* w2 {4 d# H# z: P, S0 u
7. void Uart1TxData(uint8_t *pData,uint16_t Count);
   
8. 
   
9. #endif /* End __Uart_H_ */

复制代码

这个是应用文件，实现了把收到的数据在发回去的功能。

1. #include "Uart1Task.h"
   + V. M" @$ R+ b4 h0 u
2. #include "limits.h"//ULONG_MAX
   5 A  j0 V) A, |
3. #include "Uart.h"
   
4. #include "string.h"
   
5. #include "SystemConfTask.h"
   9 w* b: J' m* l8 N) r( B
6. 
   
7. #define Uart1RxCompleteFlag  0x01
   0 z& F8 \, Q/ s8 U" v
8. 
   9 ]4 A" _% J' @: W
9. static uint8_t *Uart1RxData;
   
10. static uint16_t Uart1RxCount;
    $ v* B/ p7 }" m2 m
11. TaskHandle_t Uart1TaskHandle;
      G1 i& T% O) i! b5 M
12. 
    
13. void Uart1RxIRQ(uint8_t *pData,uint16_t *Count);
    
14. 
    
15. TaskHandle_t *GetUart1TaskHandle(void)
    & g. s3 y: C4 L5 ~
16. {
    
17. return &Uart1TaskHandle;
    ' ~2 X8 ^; A" o+ q1 j& O
18. }
    
19. 
    
20. void Uart1Task(void *pvParameter)
    
21. {
    
22. Uart1Init(115200,Uart1RxIRQ);
    
23. while(1)
    " I+ o' \" @2 W+ j" i* Y- [( ~2 M
24. {
    
25.   uint32_t NotifyValue = 0;
      ^; i/ N/ z7 j2 O
26.   xTaskNotifyWait(pdFALSE,ULONG_MAX,&NotifyValue,portMAX_DELAY);
    1 z( {* D3 R2 [  i+ N$ P/ s
27.   Uart1TxData(Uart1RxData,Uart1RxCount);
    & d7 {5 G+ b- ^7 f
28. }
    
29. }
    4 K, d2 j( Q* S: t
30. 
    
31. void Uart1RxIRQ(uint8_t *pData,uint16_t *Count)
    ; t: J4 g# r1 D
32. {
    
33. Uart1RxData = pData;
    
34. Uart1RxCount = *Count;
    , w: {/ {+ d! ]5 i5 ?
35. BaseType_t pxHigherPriorityTaskWoken;
    4 p+ U2 _& n  z. d  I- f$ J
36. xTaskNotifyFromISR(*GetUart1TaskHandle(),Uart1RxCompleteFlag,eSetBits,&pxHigherPriorityTaskWoken);
    / F6 U+ J+ y8 R  y' b  i  [$ c, H
37. portYIELD_FROM_ISR(pxHigherPriorityTaskWoken);
    ' r' i: D) \" W# W! E1 L
38. }

复制代码

! M8 @  _: ?( R2 H- ]串口驱动里做了一个双缓冲的，防止大量数据出问题

& B2 A  f. D" P* }1 v$ {9 Q
- J! I1 S2 D8 D( z& e& K+ X/ P