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

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)                             
   
9. //    {
   
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    
11.         while(1)
    
12.             {
    . k) [% X2 \* Z9 t/ M
13.                 if(__HAL_DMA_GET_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    ! b9 f$ ^/ q) {* N. y6 D
14.                 {
    
15.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart1_tx,DMA_FLAG_TCIF3_7);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
17.                     break;
    
18.                 }
      }: Z. {8 E; l% x8 L) O
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
20.                             }
    4 |- f- x# a: G; D- b9 j" }3 k
21.         switch(sta)
    , T; F$ P7 H# A* T
22.         {
    ; K; u, F6 }  N! _+ j+ n5 O
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;
    5 x( r# B; J$ K, L1 C9 W7 p
25.             case 2:mode = 0;sta = 0;break;
      x# s  H  X, t) i* {+ D1 ]
26.         }        
    
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    
28. //        }            
    9 L& t. |, `" \) C8 t: R0 V1 J" {, E
29.     }
    0 v1 n2 l9 d$ L
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
    - l0 @' A) U8 z1 T* u# f0 G. K
31.     {
    1 ?; ~0 X( R& n0 P2 `
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    
33.         while(1)
    4 I2 z+ o( a$ f( X. E
34.             {
    
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    $ X) M0 ?& c8 Z. ]# D
36.                 {
    , b" Z3 f" |- ?5 \: {7 e* Y
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    / L# l% t+ E; g* f) @) G5 d7 p( K: z
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    . {5 h( h. ]  J9 }
39.                     break;
    9 P. u3 m/ k) S; t
40.                 }
    ( J: s$ T2 k2 i" `" F+ ^
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
    . Z3 C2 ?3 p7 Y2 j
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    ) O$ U( l6 P$ d6 K: }( ]
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    . |7 I6 Z! Z+ d( x, }' H: G
45.     }
    
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    ( f* r1 T& O7 z
47.     {
    2 B+ O; W; l, j2 v
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    % f5 n6 W1 Z' f& v: F6 f# B& U
49.         while(1)
    4 K9 F. S0 F5 W; G- L$ H- {
50.             {
    + q4 ~) ?( I# H/ S
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´«ÊäÍê³É±êÖ¾
    
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
      B& r/ {! x- f* y7 u2 f
55.                     break;
    
56.                 }
    ' g4 }5 u% n7 j, \' H
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
    
61.     }
    
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    ; f, b* q$ O3 B- J8 `1 o  y
63.     {
    
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    
65.         while(1)
    
66.             {
    ! T2 p+ i6 z5 c5 l) v% Z* u
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    : U% v. s) z0 {, N& n
68.                 {
    7 x; j* c8 _; n; O  A  ~( A3 [+ O
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
      P5 ]' ^. B7 E7 o
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
71.                     break;
    
72.                 }
    
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    . V7 N1 ^+ v0 j, s( D
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    
77.     }
    " L& }$ _, J) n. V6 c; N
78. }
    

复制代码

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

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   
2. 2 {
   
3. 3         uint32_t isrflags   = READ_REG(huart->Instance->ISR);//?????,???????SR
   9 v* n$ V. Q  H" t
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);//???
   7 b9 E, h1 F; m
8. 8         }
   
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   & f. Z2 q* Y, K7 V
10. 10         {
    ! m1 ^- G( I. R
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    + s" c8 g8 l" W! k
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    5 m3 P# ~8 _- e2 o- G* f. ?. ?- F
13. 13         }
    ) S' c; }. w6 U. G4 ?7 E
14. 14         
    ( ?1 k: D6 e$ V& Q7 X  F
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
      K5 A  N* ^' t, ~
16. 16         {
    8 D$ l  F0 L9 }+ p5 X' ]* ^! ~
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    ! w+ K; J3 f# b
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
    ' R. j$ V9 D& Y* }/ A2 X4 L
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    
25. 25         }        
    ; z1 n; N8 p0 S( Z$ `4 m
26. 26 }

复制代码

% E+ X) M8 d1 p/ p, J4 p; x! \
3 p4 {" G5 S, b  k7 Z9 w6 O9 a: l
. d' R" T) Y! j; \  y# R