一、STM32CubeMX开发
1.1 新建工程
! L6 o% F& n6 l  ], [" Tfile -> new project
2 K% L# E6 j6 f* f! X9 H# E
$ D. P% x3 g+ r& Z4 b4 c# u* P选择芯片-> stm32 core内核         

                   stm32 series 系列

                   stm32  line
! P5 W) B& I* G: k+ M
                   stm32  package
& Q8 P: g. @& x$ s) A: Y" U, B
选择芯片根据自身需求去选择，目前该项目是stm32f0系列
5 x! T% J; l1 a
                    stm32 core内核         M0
) b- V0 w6 w" Q
( Q7 t+ D; G$ Q) d1 V/ w                   stm32 series 系列      F0
' U& K, J- A1 U- ^  \; f9 _% K) Q
* o4 u0 n; v: w) y2 g! ~5 m( B                   stm32  line                 F0X1

                   stm32  package         TSSOP 20

1.2 配置 USART1
  q9 k% T8 i; ?& [3 @配置 USART1 的模式为 Asynchronous，即异步串口模式
( Z' w4 t8 c0 ?* v5 c) a5 f; ]+ w
5 f) a9 z6 R( M! `) Q- p! X

$ F. n$ M8 \3 W" y! ^9 b! z
1.3 配置串口参数
7 u# X: B: @7 m* @8 G, y2 T! d 根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1

8 z7 Z- g, O. G/ T( {

7 b- r, [* Y( o' T, | 1.4 设置DMA
- B1 _7 Z% f5 f7 F& ]# K2 ?

2 m  d- k8 T& S% y8 |
1.5 添加串口中断
1 V' M& j8 z5 ]. K" W  _* U6 v

) G8 g8 Z# J+ X# O4 ?) D" f
1.6 生成源代码。
在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。
' h2 z5 e- D- ], T5 n  f
3 m: i0 O- q* Z% {

生成代码完成后可选择打开工程。

3 Y) P0 t1 k- @$ i
二、代码部分
5 h0 ?8 w& H( {8 m- y2.1  接收中断处理
5 e3 w! G. C+ k- F! [2.1.1 接收固定长度：（舍弃）
1 E- E; Z8 [& Z7 V1 V9 J只有接收缓存到固定长度才会触发中断
* s) |, ]: d) R: e7 c+ u串口接收回调函数
  [- M& s! O* ?6 ?1 n: Z1 o. ?

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   
2. /* Size of Reception buffer */
   ( P- x! N( c" e: o1 Z. {
3. #define RXBUFFERSIZE                    10
   + _+ T8 k# z: t, b3 q
4. 
   ; f# L, s2 |: G; m; q
5. 
   
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   
7. {
   ; ]9 H" `1 n9 `3 `  q! G4 F
8.   /* Set transmission flag: trasfer complete*/
   
9.   UartrxReady = SET;
   
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    9 _3 t0 z0 T4 N3 E
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    4 y6 ?- d5 m* k5 b* c; j
13. 
    
14. }
    
15. 
    4 ?5 @3 }$ j9 g' h: {/ S
16. void USART1_IRQHandler(void)
    
17. {
    ! s( q5 `; p  H8 ^
18.   HAL_UART_IRQHandler(&huart1);
      i0 H" V$ l7 J5 \5 V) d1 i7 K+ W
19. }
    6 i3 w5 \( J5 V# g
20. 
    
21. 
    . V1 u% V) a7 v  R2 X1 ~
22. static void MX_USART1_UART_Init(void)
    7 `7 O, Z2 o6 v4 z5 G8 E
23. {
    
24. 
    
25.   huart1.Instance = USART1;
    % ~) \2 L2 a; f9 |3 `
26.   huart1.Init.BaudRate = 9600;
    
27.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    
28.   huart1.Init.StopBits = UART_STOPBITS_1;
    
29.   huart1.Init.Parity = UART_PARITY_NONE;
    , G) p: ]$ x* S
30.   huart1.Init.Mode = UART_MODE_TX_RX;
    ) x3 C8 b' w! K! a6 x: I1 D
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    ; ]( W: f+ U. S& d- i
33.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
34.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
35.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    ! o) }  R# \- A( H* j) M& ]1 [+ ^
36.   {
    
37.     Error_Handler();
    
38.   }  
    
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    2 o: [5 O- a$ Y- Y$ B& h4 e
41.   {
    
42.     Error_Handler();
    
43.   }
    . R1 J0 J) \2 ~6 O3 h) ]$ a
44.         
    ; Q+ y4 J6 @4 i; Q* W
45.         UartrxReady=RESET;
      Y& O3 X  S- a* n
46.   /* USER CODE BEGIN USART1_Init 2 */
    8 ^7 h* [  Q% ?  z
47.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
48.   {
    
49.     Error_Handler();
    
50.   }
    
51.         
    
52.   /* USER CODE END USART1_Init 2 */
    8 X4 n# y- X2 E2 j% D- y
53. }

复制代码

从串口调试助手可以看只有接收的长度 RXBUFFERSIZE为10时，才触发接收回调函数。

( P; w3 n5 K  i; Q2 ]

) k$ H2 U4 X9 ^3 s2.1.2 编写空闲中断函数接收不定长
. f4 h3 C& `% w, wUSART1初始化：
3 s+ |# Q. {1 d. Y/ t- g4 P

1. static void MX_USART1_UART_Init(void)
   
2. {
   
3.   huart1.Instance = USART1;
   # Q# K! i4 o' u2 a; b9 r
4.   huart1.Init.BaudRate = 9600;
   8 c3 W, Y5 `: H0 x
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   - U6 R1 ?. }- O% r' U# S
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   # G) k. R4 p- F& c
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   + p* t' z0 ^6 Q
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    7 L8 q! Q- }  R$ G* z3 E! \
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    - Z' U3 U# A9 u, i. G+ M. x! R( l5 i
14.   {
    
15.     Error_Handler();
    
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    
20.     Error_Handler();
    
21.   }
    
22. 
    6 N, H0 r, }7 s/ D- ]  p$ Q
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    0 k4 R4 H) p0 A
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    9 o& n" d; b- {( A$ ]/ V" d6 ~& ?
26.   {
    
27.     Error_Handler();
    
28.   }
    
29.         
    
30. }

复制代码

3 m* F( \: ?- z7 |  ^4 d, H& m1 B空闲中断函数：
8 ]2 b8 ?. v/ N3 A4 k* [

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    30
   & L& a2 J- f( m1 s
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
6. {
   
7.     HAL_UART_DMAStop(&huart1);
   
8. 
   
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   8 K" g0 k( W- m, ^. {$ i) ]& |  ~4 `
10. 
    4 P2 Y5 q8 J; f5 \0 L% @6 G
11. 
    
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    6 A! h+ S# ?  Q: r
13. 
    
14.     memset(aRxBuffer,0x00,data_length);
    2 {7 o0 P# L" J. f! K& j
15.     data_length = 0;
    2 {( M/ }/ m1 P7 q9 |
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    ( f: N, w! B# _
17. }
    
18. 
    , N( L, {8 r, Q3 l* w' L
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    0 u/ I, [* [( m
20. {
    
21.     if(USART1 == huart1.Instance)
    ! c: R4 t+ `. g+ o( k; ?( E
22.     {
    - }4 D& {7 l2 Q
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    ) g5 V9 P, W* }
24.         {
    
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
26.             USAR_UART_IDLECallback(huart);
    4 T' U! L# m8 Q1 z
27.         }
    ; \8 d) t" B" D  \/ L
28.     }
    
29. }
    
30. 
    
31. /**
    ; x8 x+ E* y, [
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
33.   */
    . G0 g5 S% `  M* V
34. void USART1_IRQHandler(void)
    
35. {
    & u* G. @) J& ^. W: s2 E
36.     HAL_UART_IRQHandler(&huart1);
    ) n9 x+ J$ s9 a4 k& U! o( |1 t
37.     USER_UART_IRQHandler(&huart1);
    : {' n' S/ j0 c5 I$ P9 \/ D
38. }

复制代码

可实现不定长的接收！
* q; E* E, b5 J
+ K* y8 e- M3 k4 E  |

! ^; E% U. a3 B, h; ?/ T! x
注意：
2 Q9 @% @* v7 l, \! K在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。
% l! g0 O$ V' V+ ?1 L$ j5 ~3 ?. V
) D5 E0 [  |, J7 g 三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
使用原因：

; a1 g$ m) M- Z* S/ K        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。
0 ?4 {7 t$ O& }3 c2 i) |8 X2 _+ Y
# ?/ K9 Y! ]1 S6 ]) L* q        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖
* X6 G$ c4 R, R/ {& n9 N
; Y  u) z; g! r* }' m" t① fifo头文件：

1. #ifndef        __FIFO_H_
   6 s+ j" t& o+ Z  t! J+ x# I$ q; Q- B8 Q
2. #define        __FIFO_H_
   
3. 
   ) O- i9 @9 h6 F
4. #pragma pack(4)
   7 r4 p" S4 I6 ^' y$ U! A6 X0 O+ c
5. typedef struct FIFO_Type_STRU
   # s# U1 w% W: U. H; h2 c
6. {
   
7.         unsigned int                        Depth;                        // Fifo深度
   + J8 L9 k/ m* M" G3 [" P, w2 W
8.         volatile unsigned int        Head;                        // Head为起始元素
   2 x; U& [' e8 \& Q) D0 Q2 X- ^
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    + \& s7 J! [. r0 D
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    ) ^* B0 Q" k/ x4 g+ J: |+ J
12.         void                                        *Buff;                        // 缓存区
    
13. }FIFO_Type;
    
14. #pragma pack()
    
15. 
    % T1 `0 L/ d5 e7 X- S$ `% d
16. /********************************************************************//**
    
17. * @brief       FIFO初始化
    $ a; {2 s& }( ~0 O1 F
18. * @param[in]   pFIFO: FIFO指针
    . r, K* K% g8 J- ]) p4 Y4 U
19. * @param[in]        pBuff: FIFO中缓存
    
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    3 E5 S7 @+ n& l8 J$ Z9 K
23. *********************************************************************/
    
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    
25. 
    
26. /********************************************************************//**
    / I& R. f4 e* m  C1 Z& y3 A( j. K
27. * @brief       向FIFO添加一个元素
    5 S/ t' a0 `! l& k
28. * @param[in]   pFIFO: FIFO指针
    
29. * @param[in]        pValue: 要添加的元素
    # v" I& f. @( }1 M
30. * @return      1-TRUE or 0-FALSE
    - F" z, M, Y, j1 Z
31. *********************************************************************/
    0 V) F% _, H" K4 m5 f6 z
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    & K2 u" U& d& }% g& W7 o$ P  a
33. 
    
34. /********************************************************************//**
    9 k- Q# q; l  u0 [9 @( H3 a+ I
35. * @brief       向FIFO添加多个元素
    
36. * @param[in]   pFIFO: FIFO指针
    
37. * @param[in]        pValues: 要添加的元素指针
      p) p% T# i0 c3 y) `! @/ c1 B
38. * @param[in]        bytesToAdd: 要添加元素的长度
      W! g/ d! K4 P) }2 v, l0 a( Y' n
39. * @return      实际添加的元素个数
    % _/ `4 m, N, |+ K: X7 J
40. *********************************************************************/
      c: ~* \/ `; A& J
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    
42. 
    % c" V( @& |* y2 i% g
43. /********************************************************************//**
    
44. * @brief       从FIFO读取一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    + j, M# ^6 [! A
46. * @param[in]        pValue: 存放要读取的元素指针
    ) n0 x3 k2 k4 Q& ]2 i; C7 N9 i
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    
50. 
    0 K  A- C2 k' M( @- A) w1 f, |
51. /********************************************************************//**
    1 P# W4 U+ j: }. k3 T0 F
52. * @brief       从FIFO读取多个元素
    ! J7 `9 u5 r0 [4 |7 z! J! ^! l
53. * @param[in]   pFIFO: FIFO指针
    
54. * @param[out]        pValues: 存放要读取的元素指针
    
55. * @param[in]        bytesToRead: 要读取的元素长度
    , q: u- K/ d% E, _+ W
56. * @return      实际读取的元素个数
    
57. *********************************************************************/
    
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    
59. 
    . U; o" X2 p/ P" ?( Z  E' R
60. 
    # p3 @( ^6 h9 g- u% @: i) L" p
61. /********************************************************************//**
    
62. * @brief       清空FIFO
    2 U/ P' |. ^# M; K# ^0 f
63. * @param[in]   pFIFO: FIFO指针
    9 G9 w- S, i5 A& ]' n
64. * @return      None
    
65. *********************************************************************/
    % j9 i2 v  l" A1 G% K9 n
66. void FIFO_Clear(FIFO_Type *pFIFO);
    6 Y  g9 V' S$ [5 S% ?& z& ~
67. 
    
68. 
    # j4 E. ^! H2 O4 r% a! w8 F
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    . B0 Y  E) Q" }6 C
70. 
    ; Q+ v# F* S1 `. w; n
71. #endif

复制代码

, e8 i& t, T3 p1 l( o1 ~② fifo.c程序主体
) H5 V+ ?: w$ ~0 p& o, f* p; H

1. #include <string.h>
   
2. #include "fifo.h"
   7 a. `8 m5 w8 B4 e/ C) t8 `" @
3. 
   
4. 
   5 y4 T4 l  l0 b" ]8 o# ?
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   ; c, k5 w8 T" I! J$ F0 a
7. * @param[in]   pFIFO: FIFO指针
   
8. * @param[in]        pBuff: FIFO中缓存
   ; E: T9 m6 u6 b' M
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   
10. * @param[in]        depth: FIFO深度
    : I) _9 ^: D5 L
11. * @return      None
    , h$ t' N3 L8 C  r  O
12. *********************************************************************/
    
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    
14. {
    
15.         pFIFO->Buff = pBuff;
    
16.         pFIFO->ElementBytes = elementBytes;
    
17.         pFIFO->Depth = depth;
    
18.         pFIFO->Head = 0;
    5 u8 N3 b) J, D
19.         pFIFO->Tail = 0;
    # F. A# z, P6 |9 a
20.         pFIFO->Counter = 0;
    0 I" l% B/ W! z, u5 B0 Z0 W
21. }
    
22. 
    ; \5 o. w  Q! g" w8 ~
23. /********************************************************************//**
    8 E5 t$ B" x; c$ J* O
24. * @brief       判断FIFO是否为空
    
25. * @param[in]   pFIFO: FIFO指针
    7 x) b3 o( q8 o
26. * @return      1-TRUE or 0-FALSE
    
27. *********************************************************************/
    4 X" G/ I. i( N! c& P; V  h+ T
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    & a/ w7 A, Z" m
29. {
    ' y9 G" S  [/ B
30.         return (pFIFO->Counter == 0);
    
31. }
    8 e7 u  k. I! A" ^; {
32. 
    & k: F2 a& l$ l8 [
33. /********************************************************************//**
    
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    
36. * @return      TRUE or FALSE
    
37. *********************************************************************/
    . D7 u6 @- `- s
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    , D' f' a* a( I  \+ w
39. {
    
40.         return (pFIFO->Counter == pFIFO->Depth);
    : n# _" T) u& n5 n* k5 q
41. }
    
42. 
    " ?! ]+ T) c5 x9 L
43. /********************************************************************//**
    $ D9 W3 Q" G: Z7 N) v$ a" G. D
44. * @brief       向FIFO添加一个元素
    1 l3 O. ]& y3 a" j& }, }, B2 u
45. * @param[in]   pFIFO: FIFO指针
    + s5 y6 l  B; @( N8 ^6 l
46. * @param[in]        pValue: 要添加的元素
    
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    7 \7 _) r+ u" ^1 l5 R$ Y; _
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    
50. {
    
51.         unsigned char *p;
    7 y+ J- V$ M' H% _# V
52. 
    
53.         if (FIFO_IsFull(pFIFO))
    5 @& h1 `2 {3 k# k
54.         {
    
55.                 return 0;
    
56.         }
    5 C2 @' F2 f7 _* H5 }0 f
57. 
    
58.         p = (unsigned char *)pFIFO->Buff;
    
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
    9 n5 K2 [: B: c& S- U* N4 d
60.         
    
61.         pFIFO->Tail ++;
    
62.         if (pFIFO->Tail >= pFIFO->Depth)
    
63.         {
    # f; W) b! R* Y7 m+ a2 d6 N
64.                 pFIFO->Tail = 0;
    
65.         }
    
66.         pFIFO->Counter ++;
    3 J  Y& L7 x. V4 _3 ~
67.         return 1;
    + k2 D! k2 @2 `0 f. ]3 M
68. }
    ; L" z% S4 V" A7 v) e' {
69. 
    
70. /********************************************************************//**
    
71. * @brief       向FIFO添加多个元素
    % C1 w3 N" U# K9 J8 R' Z; \
72. * @param[in]   pFIFO: FIFO指针
    ) L1 [' x, |/ {0 Z& E0 v% S2 `
73. * @param[in]        pValues: 要添加的元素指针
    
74. * @param[in]        bytesToAdd: 要添加元素的长度
    
75. * @return      实际添加的元素个数
    1 v% R% w* r* X3 P
76. *********************************************************************/
    
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    
78. {
    
79.         unsigned char *p;
    
80.         unsigned int cnt = 0;
    5 j3 ^, L2 _% p! ^; H
81. 
    
82.         p = (unsigned char *)pValues;
    ' I$ G$ n: C1 Z% d/ t7 z% T
83.         while(bytesToAdd --)
    - z* b. o5 ^  J4 c
84.         {
    
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    + |0 j$ y3 v  [" u0 Z5 q4 {
87.                         p += pFIFO->ElementBytes;
    ) h4 G' J2 z" E! f
88.                         cnt++;
    
89.                 }
    
90.                 else
    7 j0 K2 H( ^0 s3 Y
91.                 {
    
92.                         break;
    0 w" c8 M" E  l5 L
93.                 }
    
94.         }
    : U$ ?/ e& h9 z3 ~* u% K! a% @3 X& a- `
95. 
    & j, y+ c( d; j8 `1 ]: ?1 N5 l
96.         return cnt;
    1 I1 {6 D4 Q6 |" R5 S
97. }
      ?4 K. X. f: H' h+ T1 }# L" c
98. 
    
99. /********************************************************************//**
    
100. * @brief       从FIFO读取一个元素
     
101. * @param[in]   pFIFO: FIFO指针
     ( n8 t: l8 L) Q
102. * @param[in]        pValue: 存放要读取的元素指针
     
103. * @return      1-TRUE or 0-FALSE
     ' \0 O- a: H1 G, O& s
104. *********************************************************************/
     ; a  F# r* h9 n- H/ U0 Q/ T
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     0 K2 p: }5 I. c& j; T9 j; P
106. {
     - ?1 t9 T, C& k+ P8 Z5 `& L5 A
107.         unsigned char *p;
     
108.         if (FIFO_IsEmpty(pFIFO))
     
109.         {
     
110.                 return 0;
     - W+ R; t- L* B. i: F* {& t# G
111.         }
     
112. 
     0 O3 _. I( [0 x
113.         p = (unsigned char *)pFIFO->Buff;
     
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     - k! h% N' K% |9 l
115. 
     3 {( o/ f( ?5 R( g, W
116.         pFIFO->Head ++;
     
117.         if (pFIFO->Head >= pFIFO->Depth)
     
118.         {
     5 U$ Z% ?8 i0 G5 L7 A& A/ E/ I
119.                 pFIFO->Head = 0;
     
120.         }
     
121.         pFIFO->Counter --;
     ! p- }) C% t9 R: m) u( e
122. 
     
123.         return 1;
     , g- N6 b3 Z* g8 I/ f( W5 ^
124. }
     - K( p$ b- G! m, h' z' M7 v* n, _
125. 
     
126. /********************************************************************//**
     4 X  ]! d' z2 ?/ z, I
127. * @brief       从FIFO读取多个元素
     ' \; n% q6 V. ]$ P, l( C, I( b
128. * @param[in]   pFIFO: FIFO指针
     
129. * @param[out]        pValues: 存放要读取的元素指针
     , u$ N' a2 G0 W& S
130. * @param[in]        bytesToRead: 要读取的元素长度
     
131. * @return      实际读取的元素个数
     
132. *********************************************************************/
     
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     
135.         unsigned int cnt = 0;
     # J/ W" ^# M# H( F* h- A5 Y' |0 E
136.         unsigned char *p;
     
137. 
     
138.         p = pValues;
     - _& e  k7 |- S
139.         while(bytesToRead--)
     
140.         {
     * F4 Z6 H' C, H3 N: G, R. g3 c
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
     
143.                         p += pFIFO->ElementBytes;
     7 Z+ S8 g7 R$ Q8 A3 t  Q4 M
144.                         cnt++;
     0 o* \* n2 P7 t" Q
145.                 }
     
146.                 else
     % X3 [; ~9 Z* ~% h+ V% d
147.                 {
     9 `1 T' q% U+ b+ q
148.                         break;
     ! _$ ~5 `5 @. f& D
149.                 }
     1 D8 Z' h6 X  C8 O$ @8 d7 i. a; w- d6 \/ W
150.         }
     
151. 
     ; {" R; K. U( \% f: f+ {" S! M
152.         return cnt;
     3 @$ A) S5 q% {
153. }
       Q6 r9 E4 h9 m+ _! l" `
154. 
     
155. /********************************************************************//**
     + r" l- r2 R/ q% c7 _$ E$ @
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     3 I7 B* C# d; w- L
159. *********************************************************************/
     
160. void FIFO_Clear(FIFO_Type *pFIFO)
     * ?" ^# F' w9 M: i. L
161. {
     , V- |  Z% ~& i* I7 ?
162.         pFIFO->Counter = 0;
     
163.         pFIFO->Head = 0;
     / P7 e& v; h+ Y6 O1 f5 u- |& w5 m- \
164.         pFIFO->Tail = 0;
     ' a" J. b6 e8 }; Z( H
165. }

复制代码

③ 串口初始化

1. static void MX_USART1_UART_Init(void)
   
2. {
   " O: C7 S- Q# b" ^
3.   huart1.Instance = USART1;
   
4.   huart1.Init.BaudRate = 9600;
   ! D# o3 _3 @, p
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   , p* }% ]8 p( o- N4 n
7.   huart1.Init.Parity = UART_PARITY_NONE;
   1 i1 X8 Q: ]) c2 \8 L6 o
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   + H3 J$ I7 D2 F5 k* x) f0 P9 b9 i
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   2 m  A' r, f. {  q' h% t
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    6 _  S  L! H0 O
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    
14.   {
    6 p, N; M. w' u1 i- Z
15.     Error_Handler();
    8 _3 d! V, }8 m3 Z. I- z; Q% f6 E# L
16.   }  
    
17.         
    ' O2 G  i, T1 G. {. k0 w  `
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    
20.     Error_Handler();
    
21.   }
    + S8 ?8 h8 R/ _& X
22.         
    + W* Q3 u3 M2 L2 v, ^+ @
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    3 I  _' q' h) R2 n' q1 j
26.   {
    
27.     Error_Handler();
    
28.   }
    ) B6 T. {/ X2 W8 r
29.         
    
30. }

复制代码

$ P; k5 g/ J1 M8 W& g. \ ④ 接收空闲中断
1 T+ J% W) s! N  |1 Q/ X9 e* Y# \4 Z6 v

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
2. {
   
3.     HAL_UART_DMAStop(&huart1);
   ) d7 Y6 a: l' S/ \9 v* Z, p
4. 
   + E0 F2 ~5 ?/ S" H8 W2 x: J
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   % u$ T3 D4 \( {! w  N6 s
6.         
   
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   0 c. N3 t# m7 s6 R
8.     data_length = 0;
   ; J3 {7 C: q4 `6 R9 t9 w! W2 _* g
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   
10. }
    
11. 
    ( _/ B. A% O# X% t! {0 ~
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
13. {
    8 n6 k' C( ]  P1 \  J: r4 X
14.     if(USART1 == huart1.Instance)
    * {5 T" {, P' S7 r6 K5 d# O, |5 R
15.     {
    
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    & O  z  w! @$ t7 d- S5 G
17.         {
    
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    : Z/ V4 m. \& L- k
19.             USAR_UART_IDLECallback(huart);
    2 r) M' g& s- g& A9 c
20.         }
    
21.     }
    
22. }
    + R: j$ f2 n5 x% H
23. 
    ( o# y  X. n: g, ]  g0 b+ E$ u
24. /**
    1 Q) O* j: x; a
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
26.   */
    
27. void USART1_IRQHandler(void)
    / V& t% H4 Z* U9 x5 Y8 d5 u
28. {
    $ p# F7 G; w3 z
29.   HAL_UART_IRQHandler(&huart1);
    3 \. M, Z: ?/ Z/ l8 b( t5 J
30.   USER_UART_IRQHandler(&huart1);
    
31. }

复制代码

⑤ 主函数调用：
" v" @* ?) ]6 F! j' E+ s; H

1. #define TXBUFFERSIZE                    30
     d7 a; w8 X0 f" y1 r
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   
5. 
   2 m) u: k4 _/ T# F2 e: t0 x
6. 
   
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   
8. 
   . ]( ^# m7 {" X- D2 a
9. /* Buffer used for reception */
   2 t0 k# [6 Y( R4 h5 E# G: i- ?
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    
11. 
    
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    
13. FIFO_Type        fifo;
    
14. FIFO_Type        *pfifo;
    
15. 
    7 z! I' A3 l2 _+ O: X" K. l* h2 ?
16. int main(void)
    " q$ t" n% J" \% S1 @7 G
17. {
    
18.   /*此处省略硬件初始化*/
    
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    ' U! Z' r2 e0 z9 h
20.   {
    
21.     Error_Handler();
    8 G% i3 R& ?  i. k  F, u/ @
22.   }
    
23.         
    
24.   pfifo = &fifo;
    
25. 
    
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    
27. 
    
28.   while (1)
    
29.   {
    
30.         /*一次接收的缓存，重新发送*/
    
31.                 if(!FIFO_IsEmpty(pfifo))
    $ b+ `! F9 s4 g) h2 @3 w
32.                 {
    4 z. |1 `3 b) Q  T
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    / D; d% d* V. C; N
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    . |7 @/ |# u2 q( y
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    
37.                 }
    
38.   }
    ) o4 T; z7 z1 P: M" P" l
39. }

复制代码

测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！
( H, L$ @7 b4 {, b5 T% |& R( L

" B; I: S( F* j+ e$ y! c" Y
. B* b% F# k3 e) E- `问：关于 stm32 HardFault_Handler问题处理？

ANS：

1 @- p* ^0 }8 c" ^* l2 m' t) E        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，

4 s$ C6 T3 j. r1 X6 ~  j8 A

最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！

1. pfifo = &fifo;

复制代码

& o; i" f5 r- C; a$ q6 ^% ]