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

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;
   2 _; Z, N! @1 Y% {, j8 E% W/ Z
4.     if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
   
5.     {
   
6. //        USART_RX1_BUF[Usart1_len]=aRx1Buffer[0];
   
7. //        Usart1_len++;
   
8. //        if(Usart1_len == 0x04)                             
   
9. //    {
   
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    1 d2 g: A! Y0 P+ L' P: C' ]5 W1 _
11.         while(1)
    
12.             {
    ) {2 ~+ m% I; L: |2 A
13.                 if(__HAL_DMA_GET_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    ( a+ Y8 C$ A) d2 ]3 l1 A8 |
14.                 {
    
15.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    8 W, C7 H; N; k- F. C0 M5 ~
17.                     break;
    
18.                 }
    
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    9 E4 _9 G$ L& @" E
20.                             }
    8 }7 Y! i  G# R& l- l
21.         switch(sta)
    
22.         {
    1 [( E7 ~1 m; w) Y5 z; @
23.             case 0:if(aRx1Buffer[0] == 0x55) sta = 1;break;
    8 P& h8 A  u) I: C) A& Z+ P- f
24.             case 1:if(aRx1Buffer[0] == 0xaa) mode = 1,sta = 2;else sta = 0;break;
    ) S7 F$ X* S8 ^/ _& X
25.             case 2:mode = 0;sta = 0;break;
    & l5 ^% V6 }6 ?  h8 Z# U! U
26.         }        
    
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    7 h/ p7 U3 j9 d2 M" J
28. //        }            
    
29.     }
    
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
    
31.     {
    
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    
33.         while(1)
    / p- ~# w2 D; d
34.             {
    9 `0 ]8 M4 p) q% M- r2 C$ h- A
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    " U4 f9 N, l9 b
36.                 {
    3 E6 l! |8 j: ?) g7 m3 X
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    7 @. q( ]% a2 v3 ?3 k; z
39.                     break;
    
40.                 }
      s$ G% V3 x" F) O9 t
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
    
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    4 \  Y. T3 u  `+ s; N$ O
45.     }
    
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    
47.     {
    
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    . c: Q) B6 Z- _# C" J, L: {
49.         while(1)
    1 I, l& g9 @/ f% S+ p( M
50.             {
    ' ]  n# y' ~; N! [5 t+ g) V
51.                 if(__HAL_DMA_GET_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    ' n8 Y# j% d( S; I$ a" \
52.                 {
    
53.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    - _. B) C; r/ k' m! J# R. {
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    ' b. e/ [& c, I8 C) |
55.                     break;
    
56.                 }
    
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    & M' N+ g! q( w  \* l
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
    ( H: G3 j3 w2 d+ M5 h! X! _
61.     }
    
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    : E! t3 `4 }. l, [
63.     {
    
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    5 _0 ]" s+ A2 e4 Q
65.         while(1)
    
66.             {
    
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
68.                 {
    & h" n( I' |9 d2 q0 i, _' C7 ?5 G
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    7 \7 e) ~9 h. a' w
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    3 ?8 J% ]0 d0 l, [$ L$ N! d* L
71.                     break;
    
72.                 }
    / O0 S- }. F! F# q, t/ X! m
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    # b; A& p5 F$ S* E8 k5 O
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    6 L1 ^5 @  F: ]  K. e
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    
77.     }
    # d2 x! t3 u+ g1 k7 I
78. }
    

复制代码

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

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   ( r* S& Y( ~3 {: z
2. 2 {
   
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         {
   $ O+ }7 f/ i; O6 b8 u' d& C
6. 6                         READ_REG(huart->Instance->RDR);//PE???,????DR
   
7. 7                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);//???
     h9 j4 g" n; c: \$ Y; ~& g
8. 8         }
   
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   * x( a" o9 B7 M3 ~+ t* I# r
10. 10         {
    / ~6 H2 D/ u8 [# i; k+ p1 c" k0 I
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    6 I9 F0 v. r" t: \5 Z$ h: C! s
13. 13         }
    
14. 14         
    
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
    ; Q9 O/ `# k' K  _6 a
16. 16         {
    
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    
18. 18                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    % `. y; U, N$ X2 n! `
19. 19         }        
    7 E" Y3 I- ^  ~8 j3 P# u1 E$ Q4 `# X
20. 20         
    8 p1 }! f' P; N, g/ f7 P
21. 21         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE))!=RESET)
    
22. 22         {
    . k! u& a+ F! {
23. 23                         READ_REG(huart->Instance->RDR);//ORE???,????CR
    
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    4 R/ j; X7 J5 A% f
25. 25         }        
    " e7 L% S- U& U- p% _
26. 26 }

复制代码

% x* [' t, _( a2 ~