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

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

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

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

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

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

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

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

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   : Z3 ?0 Q! ?4 N. }1 y! `0 ^/ C
3.     static uint8_t sta = 0;
   
4.     if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
   + X5 z# v+ g( U9 U8 k0 H
5.     {
   0 d6 s( w% B" M: C% ^3 t; M
6. //        USART_RX1_BUF[Usart1_len]=aRx1Buffer[0];
   
7. //        Usart1_len++;
   
8. //        if(Usart1_len == 0x04)                             
   . ^6 n. O$ `7 D/ b
9. //    {
   
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    , J5 K7 Z  G1 r! ^0 t6 s2 P6 r
11.         while(1)
    
12.             {
    
13.                 if(__HAL_DMA_GET_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
14.                 {
    
15.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    0 {1 O& N$ {# R" B2 y9 K. e# }
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
17.                     break;
    
18.                 }
    
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
20.                             }
    3 K, f/ }6 Y2 a9 m5 ?) L
21.         switch(sta)
    
22.         {
    2 F7 }2 C. B/ }+ F% T) o/ F
23.             case 0:if(aRx1Buffer[0] == 0x55) sta = 1;break;
    
24.             case 1:if(aRx1Buffer[0] == 0xaa) mode = 1,sta = 2;else sta = 0;break;
    ( P4 Z& F8 t- _% A
25.             case 2:mode = 0;sta = 0;break;
    
26.         }        
    
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    * H+ I- a3 ~( v* J& z9 j) u: `1 Y
28. //        }            
    
29.     }
    ( D/ g" y2 s7 _: y6 j5 W
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
    
31.     {
    8 x# G; N4 q3 a6 B0 @3 p
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    
33.         while(1)
    6 |2 M8 g, t( D$ Z' ^. B
34.             {
    % d# b3 o; Q! V' `
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
36.                 {
    
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    8 G: u- i$ l$ y$ i9 ]2 H
39.                     break;
    ( C8 C# {+ `  F: J' J' A
40.                 }
    ) C, R: ?, U0 _6 P: z
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
      P. r$ l6 k, @& k
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    5 K* \  @& g) j+ E
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    
45.     }
    . }" W  J& p: E% G# z; B
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    ' F% n9 ]7 ?2 H* @
47.     {
    6 S# _$ f4 Y" n3 t! _
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    
49.         while(1)
    ( ?6 I6 V: h0 }) n2 w
50.             {
    + S: a1 R2 ]+ W0 b; Z
51.                 if(__HAL_DMA_GET_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
52.                 {
    
53.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    9 d& N3 Z9 [# [7 Z
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
55.                     break;
    
56.                 }
    ( d  P+ L0 S7 W5 Q3 \
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    6 H; }4 w* \( T: ^! H9 r) W% W! c
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    % N4 ]% t; C0 w, s. Q
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
    
61.     }
      j9 o9 E3 Q. [# r  R
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    $ K( l% j5 o  e7 d
63.     {
    8 {- z* g8 J( J! r9 X
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    # x6 v! r3 \% v5 f' u' J
65.         while(1)
    
66.             {
    - Y; ], g# _* X* E
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    , u8 P  E6 v, j' e8 ]2 a
68.                 {
    
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    / j( x6 b$ r' y6 [% K' z
71.                     break;
    
72.                 }
    ( L& h7 R0 G1 A, k$ J: z0 u
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    $ |0 r& u( a! O' Q2 `% o& D  L
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    
77.     }
    
78. }
    4 u2 x8 w( R# \+ i

复制代码

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

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   
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)
   4 D$ M4 A4 \! G" I- d
5. 5         {
   
6. 6                         READ_REG(huart->Instance->RDR);//PE???,????DR
   
7. 7                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);//???
   
8. 8         }
   $ B1 g; p& w1 x5 |: ?4 ]
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   & s. x( r: R3 h. Y; ?) q& H$ v
10. 10         {
    7 m+ h# H2 d( C2 j4 I2 b
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    7 \6 n4 P# h% J. ~8 Z' |
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
      c7 x3 C5 q( P* `
13. 13         }
      I  C5 I4 I; j1 [$ {9 F
14. 14         
    * w7 q8 h' T8 A( c. T
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
    ; t$ w1 X4 i7 {1 J& l( O' k9 U0 G
16. 16         {
    
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    5 k1 t. b- c3 n- ?
18. 18                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    
19. 19         }        
    
20. 20         
    
21. 21         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE))!=RESET)
    
22. 22         {
    
23. 23                         READ_REG(huart->Instance->RDR);//ORE???,????CR
    # S0 Z1 h( A- K( C$ P0 e1 P! V
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    5 D# c. x: r; G! m8 [: ~
25. 25         }        
    
26. 26 }

复制代码

3 L( \' P8 ?3 D# Y
8 s/ _# [: p3 g
! H6 g, }3 A8 Y+ H$ Z; Z" ^! m