之前没有写调试记录的习惯，导致前段时间刚弄过的一个东西，现在拿起来要么翻之前的代码，要么就再慢慢调，虽然知道自己肯定是可以战胜困难，但总是浪费很多时间，所以以后准备多写一些记录，方便自己用的时候查。嘻嘻

STM32CubeMX这个工具用习惯了还是很爽的，就是有些傻逼的地方是，他并不能给你弄到位，有的东西还是得自己调一下。

打开串口并使能中断后，如果要开启DMA收发的功能，只需要使能对应的通道就可以了。

生成代码的过程就不废话了。

在串口初始化里面调用这个函数来定义串口中断接受长度。

HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, 1);

不要忘记在中断函数里面再次调用。

一个完整的发送周期如下，清除完成标志也可以放在下次发送的开始。

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   
3.     static uint8_t sta = 0;
   
4.     if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
   
5.     {
   
6. //        USART_RX1_BUF[Usart1_len]=aRx1Buffer[0];
   
7. //        Usart1_len++;
   
8. //        if(Usart1_len == 0x04)                             
   5 L; ?. g$ _0 c0 H. B8 W
9. //    {
   & }7 R4 O, [- @7 G
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    " ~$ N) Y* u- C6 Z! F' k
11.         while(1)
    9 q$ M$ F% d9 w4 q6 S% j
12.             {
    9 ^2 e" {9 T. _2 O6 o
13.                 if(__HAL_DMA_GET_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    ( `( S( b( V4 I/ ]2 o9 T; Y
14.                 {
    5 H6 \2 h. q, d6 h$ D) c! _
15.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    ) E# L% `* N  c7 [3 T) M- W
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
17.                     break;
    / c3 m5 H% Y! y0 v6 m1 y' F
18.                 }
    
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
20.                             }
    
21.         switch(sta)
    
22.         {
    
23.             case 0:if(aRx1Buffer[0] == 0x55) sta = 1;break;
    5 t% ?8 J3 b3 ]4 O$ B
24.             case 1:if(aRx1Buffer[0] == 0xaa) mode = 1,sta = 2;else sta = 0;break;
    0 ]) |& }8 T2 ?3 C
25.             case 2:mode = 0;sta = 0;break;
    
26.         }        
    ! B) B) i( K  w+ F
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    
28. //        }            
    6 N! @# Q# h$ F# }$ S
29.     }
    3 B3 e6 s5 M& h& S, K! x* }0 ~
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
      P6 Z% {$ g. E7 W7 X1 ~% I8 H
31.     {
    0 o) D: h5 x6 P. x
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    
33.         while(1)
    : |5 @3 U" R  i$ A) _- P
34.             {
    + d* P; f- H6 p* {6 }+ C
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    # X7 k0 L6 `  X8 |" ?7 T6 Q
36.                 {
    ' t1 w  C7 i4 q' y
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
39.                     break;
      M/ u6 l' q2 h2 a
40.                 }
    
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
    
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    8 t3 ~' ?4 x/ @4 _; V
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    . h9 l$ d' n% g  T& Q' c8 @
45.     }
    * z6 n; Q# j/ I! M- m& |1 J
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    
47.     {
    , N+ D* Z( r# E: G2 b0 G6 `: A
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    - L# c& h2 Z, q) G' j$ j. X9 z
49.         while(1)
    
50.             {
    
51.                 if(__HAL_DMA_GET_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
52.                 {
    ( b* S5 J% p, p% z" ]' N' c
53.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    6 l3 i# j; J  }7 Z8 r1 e3 o
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
55.                     break;
    7 n3 M% e, J0 g. Q1 f
56.                 }
    
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    2 B8 n0 a/ s7 Y3 C- `9 q! y+ t
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    5 b$ l, \, ^. `: u4 p
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
    
61.     }
    1 i2 N' Y  E/ R* e+ M
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    
63.     {
    
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    
65.         while(1)
    & y0 R8 Z* Q0 ^! {' X, G6 C5 E
66.             {
    
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    2 \. [' \* e- x! k6 P, n' Y; O
68.                 {
    
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    - E! m9 Q9 n7 R5 S+ f0 ~
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
71.                     break;
    ' i- V: Y+ \5 z+ b2 U: Q8 p  T
72.                 }
    
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    4 e. F( c$ t0 e9 {: {
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    & ^5 N, O) N8 Y3 ^, H8 i' }3 U
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    * V! \  d" Y. h. k) g" L
77.     }
    # B7 p2 G: c6 A) [
78. }
    

复制代码

这个我是放在中断里实现串口自收自发的。

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   
2. 2 {
   . v4 x; J/ p+ R. l( w0 `
3. 3         uint32_t isrflags   = READ_REG(huart->Instance->ISR);//?????,???????SR
   
4. 4         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_PE))!=RESET)
   
5. 5         {
   
6. 6                         READ_REG(huart->Instance->RDR);//PE???,????DR
   
7. 7                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);//???
   
8. 8         }
   5 S3 H! w( r3 @7 V9 ?  }
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   8 P) ]  x/ b' H  C: Z
10. 10         {
    
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    
13. 13         }
    : I3 c; p* m1 J% e7 ?# [- T2 `
14. 14         
    
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
    
16. 16         {
    
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    * r, \! @' q1 }8 t
18. 18                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    
19. 19         }        
    
20. 20         
    ! y9 \  W/ z/ _
21. 21         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE))!=RESET)
    
22. 22         {
    
23. 23                         READ_REG(huart->Instance->RDR);//ORE???,????CR
    
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    1 F  s8 `+ R  {5 W6 Y( d  F7 p
25. 25         }        
    
26. 26 }

复制代码