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

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

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

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

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

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

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

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

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
   ) O" J* `: }& k3 Z% R7 G7 h) }. A; O
2. {
   
3.     static uint8_t sta = 0;
   ! _. m8 k# J+ C0 {
4.     if(huart->Instance==USART1)//Èç¹ûÊÇ´®¿Ú1
   
5.     {
   4 Q( }9 Z) w& M$ h" o. o
6. //        USART_RX1_BUF[Usart1_len]=aRx1Buffer[0];
     J$ j" N7 ~) c8 O
7. //        Usart1_len++;
   
8. //        if(Usart1_len == 0x04)                             
   5 k: I; K) a" L: ?. P8 Z" I
9. //    {
   
10.         HAL_UART_Transmit_DMA(&huart1,(uint8_t*)aRx1Buffer,USART_RX1_LEN);
    
11.         while(1)
    
12.             {
    % M) u, r6 C, A, e! \% S. x
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´«ÊäÍê³É±êÖ¾
    ! x1 @  y2 t0 n2 c$ R; d
16.                     HAL_UART_DMAStop(&huart1);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    
17.                     break;
    
18.                 }
    
19.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    2 u  Z4 J, x/ J& k! ~9 _) C
20.                             }
    
21.         switch(sta)
    ! J' B+ ^4 f+ Y' z* i
22.         {
    
23.             case 0:if(aRx1Buffer[0] == 0x55) sta = 1;break;
    % s9 d' R* F* k
24.             case 1:if(aRx1Buffer[0] == 0xaa) mode = 1,sta = 2;else sta = 0;break;
    
25.             case 2:mode = 0;sta = 0;break;
    6 p6 V$ A8 }2 ^/ q4 r2 T: d. L  a  |
26.         }        
    ) L3 ]2 T( p" d! _$ V; h+ y! h
27.         HAL_UART_Receive_IT(&huart1, (uint8_t *)aRx1Buffer, RX1BUFFERSIZE);   
    , p" t9 _- p( r; F, i$ Z8 s, d3 c4 r
28. //        }            
    
29.     }
    
30.     if(huart->Instance==USART2)//Èç¹ûÊÇ´®¿Ú2
    3 {* c9 |2 l" \# B( v
31.     {
    
32.         HAL_UART_Transmit_DMA(&huart2,(uint8_t*)aRx2Buffer,USART_RX2_LEN);
    % `- X6 J/ o) ?2 _% K
33.         while(1)
    ) k9 K0 b# q! W9 n. O2 h
34.             {
    & H! K5 _; c3 Z$ O: A9 }& V7 d
35.                 if(__HAL_DMA_GET_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
36.                 {
    4 c8 E/ ^  J: A+ r/ q; J* M% u: B
37.                     __HAL_DMA_CLEAR_FLAG(&hdma_usart2_tx,DMA_FLAG_TCIF2_6);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
38.                     HAL_UART_DMAStop(&huart2);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    : b+ h% \( A# Y# q9 l
39.                     break;
    # r0 ]% s8 p2 j: X  [7 |/ Y1 L; Q
40.                 }
    9 i# ?3 C) R# d$ y' B
41.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart2_tx);
    + j. u( ~/ p4 T) [" [% d
42.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    ( n$ e, j+ a# w" Z/ y+ S
43.         while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
      \" o& {+ ]# O# k/ C
44.         HAL_UART_Receive_IT(&huart2, (uint8_t *)aRx2Buffer, RX2BUFFERSIZE);   
    
45.     }
    ' j: j# p0 z- m6 |% Q
46.     if(huart->Instance==USART3)//Èç¹ûÊÇ´®¿Ú3
    
47.     {
    
48.         HAL_UART_Transmit_DMA(&huart3,(uint8_t*)aRx3Buffer,USART_RX3_LEN);
    
49.         while(1)
    
50.             {
    
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´«ÊäÍê³É±êÖ¾
    " Y' N$ T( v: `3 k0 m  p8 T
54.                     HAL_UART_DMAStop(&huart3);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    4 {! k: Q3 _: Z8 e% b
55.                     break;
    
56.                 }
    
57.                             //    __HAL_DMA_GET_COUNTER(&hdma_usart1_tx);
    # H" g  F$ r/ x- U% q$ `+ l# R
58.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    
59.         while(__HAL_UART_GET_FLAG(&huart3,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    , P: v9 F, ?& ]. D0 S
60.         HAL_UART_Receive_IT(&huart3, (uint8_t *)aRx3Buffer, RX3BUFFERSIZE);   
      M% ^# G9 O1 x  ~$ ~' v
61.     }
    
62.     if(huart->Instance==UART4)//Èç¹ûÊÇ´®¿Ú4
    
63.     {
    2 h6 W5 X7 [1 v; w' s- i
64.         HAL_UART_Transmit_DMA(&huart4,(uint8_t*)aRx4Buffer,USART_RX4_LEN);
    / j* K* U2 J: M% Y# u
65.         while(1)
    3 j1 U9 A/ G$ I" m# g) X4 s1 @5 I* Z2 F
66.             {
    
67.                 if(__HAL_DMA_GET_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4))//µÈ´ýDMA2_Steam7´«ÊäÍê³É
    
68.                 {
    $ {$ n; E; H% Y( t! |  c
69.                     __HAL_DMA_CLEAR_FLAG(&hdma_uart4_tx,DMA_FLAG_TCIF0_4);//Çå³ýDMA2_Steam7´«ÊäÍê³É±êÖ¾
    
70.                     HAL_UART_DMAStop(&huart4);      //´«ÊäÍê³ÉÒÔºó¹Ø±Õ´®¿ÚDMA
    % [8 r. P  _. ^2 I, c; {8 g8 D
71.                     break;
    ' W4 Q: m- k1 ^( _$ B) F! C' n8 L) R$ T
72.                 }
    , }, K6 c2 T, Z0 @
73.                             //    __HAL_DMA_GET_COUNTER(&hdma_uart4_tx);
    3 x- r# m0 `; ]
74.                             }    //·¢ËͽÓÊÕµ½µÄÊý¾Ý
    ( a( e( d2 R( s9 e( L5 C8 S; q0 A+ C
75.         while(__HAL_UART_GET_FLAG(&huart4,UART_FLAG_TC)!=SET);        //µÈ´ý·¢ËͽáÊø
    
76.         HAL_UART_Receive_IT(&huart4, (uint8_t *)aRx4Buffer, RX4BUFFERSIZE);   
    
77.     }
    2 W$ ^- C' ]6 M/ P4 z* ]( x
78. }
      Z" l; M+ ]1 e8 W( Y0 ]

复制代码

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

1. void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
   7 s4 \+ i: l) X* d3 y
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         {
   
6. 6                         READ_REG(huart->Instance->RDR);//PE???,????DR
   . Z0 u; T7 I1 t* D& e
7. 7                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_PEF);//???
   
8. 8         }
   
9. 9         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_FE))!=RESET)
   # X1 {; O% K9 o
10. 10         {
    
11. 11                         READ_REG(huart->Instance->RDR);//FE???,????DR
    
12. 12                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_FEF);
    / N; H: z: _. ^7 U4 N' h; J, Z8 o
13. 13         }
    + }1 e9 [: |5 u3 [0 \4 b" Z
14. 14         
    2 Z- c& }' }7 Z: x1 z  x# E9 \
15. 15         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_NE))!=RESET)
    
16. 16         {
    
17. 17                         READ_REG(huart->Instance->RDR);//NE???,????DR
    3 H: r# a* k6 e; k8 U& Q$ b  z( a: n0 n
18. 18                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_NEF);
    
19. 19         }        
      _+ R/ q' c% b- s" ^! D
20. 20         
    0 d/ R+ P2 o' W* ]& v- Y
21. 21         if((__HAL_UART_GET_FLAG(huart, UART_FLAG_ORE))!=RESET)
    ; `5 R1 `! q1 ^& @( w6 d/ I2 d
22. 22         {
    
23. 23                         READ_REG(huart->Instance->RDR);//ORE???,????CR
    - H" z# M, M) i# G
24. 24                         __HAL_UART_CLEAR_IT(huart, UART_CLEAR_OREF);
    
25. 25         }        
    % l( U6 x, _1 @' B
26. 26 }

复制代码

, g4 x0 P' o& Y$ n5 q
0 \- v2 [) p( x