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

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

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

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

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

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

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

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

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   
2. {
   " f! P  |6 G# F* S
3.     static uint8_t sta = 0;
   
4.     if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
   
5.     {
   
6. //        USART_RX1_BUF[Usart1_len]=aRx1Buffer[0];
   : r) v4 ^) m7 V/ ]
7. //        Usart1_len++;
   
8. //        if(Usart1_len == 0x04)                             
   7 y  \% I& O6 C& E' P1 h6 y
9. //    {
   ) s( e) C$ A6 J, n
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    
11.         while(1)
    ) }9 x/ X5 H8 `
12.             {
    ) ~4 C; t- |6 B* p" z1 i" @# u
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´«ÊäÍê³É±êÖ¾
    
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
17.                     break;
    
18.                 }
    6 ~0 ]8 _% b& O, `& V
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    ) o3 @7 w5 Y  K: ^; X) ^
20.                             }
    2 @, X! D3 q4 j2 s0 l
21.         switch(sta)
    
22.         {
    ' b& `; V$ o4 M
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;
      D% C0 U" N7 B1 ?
25.             case 2:mode = 0;sta = 0;break;
    
26.         }        
    % x& r$ o- |$ _7 G$ L0 w
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    
28. //        }            
    
29.     }
    6 e  Z- ]# ?' s$ p* E
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
    
31.     {
    
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    % o3 j8 @& Y! A( ?1 x$ J; ^* h
33.         while(1)
    
34.             {
    , @# H" y6 ^$ P
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
36.                 {
    " t  S# C% f( Z1 f4 K3 G, ?" u
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    - e' |" g& ?5 ~' {( H+ X
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
39.                     break;
    
40.                 }
    ' Z# S4 Q$ @3 |; v; ?
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
    5 l" N' B+ l9 q% b$ ]  N9 X
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    8 W; {" P! {. i& K
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    
45.     }
    , _+ d5 |9 p. J# p1 q9 \; U% [+ w
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    2 ^1 Q  k1 k" F
47.     {
    
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    2 d6 M1 f# T3 k
49.         while(1)
    # m8 S  h7 d2 _* O9 b
50.             {
    & |4 z, {) M7 O6 T
51.                 if(__HAL_DMA_GET_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    / m6 x$ p, a! o, O
52.                 {
    
53.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart3_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    * A" H% K8 C( z( O
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
55.                     break;
    
56.                 }
    
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    2 e& h! e/ q* A4 `0 P
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
    2 u' J3 }0 O8 h* u+ F
61.     }
    ! _8 i) z% D# Y( |: b
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    - x/ N$ }7 b, p6 V7 Z6 f: L
63.     {
    
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    
65.         while(1)
    $ P$ |( `8 Y; h6 |
66.             {
    
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
68.                 {
      ?( n. G9 ?* Q5 D6 Q1 A4 j8 Q
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
71.                     break;
    ) X! n1 H2 R# n1 h; ]
72.                 }
    ) l- o0 P( I- k2 h. [
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    8 Z9 ]2 X- ^- d' X) ~
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    ! o# F2 \' u, y/ ^% J4 Y9 k
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    
77.     }
    
78. }
    

复制代码

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

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   5 @0 ~1 B! ~0 z  S
2. 2 {
   
3. 3         uint32_t isrflags   = READ_REG(huart->Instance->ISR);//?????,???????SR
   . i* y' h( k4 i1 ^2 Z! g
4. 4         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_PE))!=RESET)
   ( o) R2 j: W7 {5 G2 L
5. 5         {
   
6. 6                         READ_REG(huart->Instance->RDR);//PE???,????DR
   , t7 S& t2 g" k& U6 i
7. 7                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);//???
   % B3 e$ U" |( z1 E* v- C+ t
8. 8         }
   
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   # ?7 C) ], p; ^5 f' }4 ~
10. 10         {
    ' s/ H+ u3 @1 w+ s
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    3 U8 Z2 l* |" j9 j- T; S
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    
13. 13         }
    0 x0 C/ P7 e- D
14. 14         
    : F, _8 i5 O3 Y7 O9 f/ p  P7 J
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
    1 A: n9 p/ j8 Z" E/ ~8 D
16. 16         {
    ! P: Z% `+ R, z7 ]- l
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    
18. 18                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    & I4 `0 M# e9 L0 M' N. ?9 @+ v
19. 19         }        
      d9 i* z$ j+ I
20. 20         
    ) t5 b4 A, p  F7 Z# \* m
21. 21         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE))!=RESET)
    " T: D+ o0 O* B% \# J: t- ]* i: z
22. 22         {
    ) P. X8 ^% q2 K% }
23. 23                         READ_REG(huart->Instance->RDR);//ORE???,????CR
    
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    : h$ X6 X  U! d& R1 Z6 I* B
25. 25         }        
    
26. 26 }

复制代码

5 W* W0 Y; J) V% x

4 j4 K) {% y  g5 N
8 Q9 v' E" b, |. g( V