一、STM32CubeMX开发
3 \; ^+ ]# Z9 w  p3 F1.1 新建工程
file -> new project

选择芯片-> stm32 core内核         
$ N- l3 b. o* p/ S( U
1 f% r3 P0 T$ `) _2 N7 W3 }                   stm32 series 系列

" U  a  v  G+ o- {* ?0 C' `$ _                   stm32  line

                   stm32  package
: C6 `. k' A5 o; `3 V) D# J3 I1 M
  |3 ~  }2 t$ ~选择芯片根据自身需求去选择，目前该项目是stm32f0系列
0 f- F( ?* q" ?8 Y
                    stm32 core内核         M0
' S4 U! ?& @+ o' \
  _' g) _* _, v                   stm32 series 系列      F0

  F' `. Q& v* Q4 e! v/ N                   stm32  line                 F0X1
  }% q: L, }* b8 [( f6 p
, }2 I. s* @- ]# {; d  _) b                   stm32  package         TSSOP 20
4 F. X& }1 f: Q7 o+ O5 S2 y
1.2 配置 USART1
配置 USART1 的模式为 Asynchronous，即异步串口模式

4 v& l. _% k3 Z

1.3 配置串口参数
  I' ]/ ~( g) ^/ b& f 根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1

. m! L- c8 `" a& W8 E

+ i0 `$ N, m' q$ j3 T$ _" j
1.4 设置DMA

& F0 [( S' `3 `# A

" K" v4 P( ~* s7 T: Q4 n
2 M- Y3 X$ F( ^$ Z2 E 1.5 添加串口中断

1.6 生成源代码。
在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。

& _- \, M7 [9 n% L9 B) W2 g; t

2 k) @' }" y" U5 r
- \( q  E( p- h6 K: V( T生成代码完成后可选择打开工程。

- L' N* M+ z1 \/ {

, {: U; H6 g! x
; R* T' t' d- {* v5 u二、代码部分
) ~, r6 N6 Z- |" r8 `9 D2.1  接收中断处理
: {7 A. x! j- F) P% M. D2.1.1 接收固定长度：（舍弃）
+ {/ @6 J  Z4 V& b2 R只有接收缓存到固定长度才会触发中断
串口接收回调函数

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    10
   
4. 
   5 p9 s1 _" O6 [% X* c
5. 
   & W, R4 @1 p  ?6 t! T- f3 R" p
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   
7. {
   
8.   /* Set transmission flag: trasfer complete*/
   
9.   UartrxReady = SET;
   * M$ i- ^2 P( e: n1 j
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    1 y* h# W3 ^( m; ?" e% E
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    + \! Z7 k7 a1 ]; b, x
13. 
    
14. }
    
15. 
    + X4 Z, S3 L! P6 {$ T9 I+ I+ C0 J
16. void USART1_IRQHandler(void)
    ) x" J8 z: q; A/ N
17. {
    # M# m' z6 n  u2 t3 O
18.   HAL_UART_IRQHandler(&huart1);
    6 H7 f/ u( }* e4 {( k
19. }
    
20. 
    
21. 
      N2 m& E( r  m5 O- C4 _
22. static void MX_USART1_UART_Init(void)
    
23. {
    
24. 
    
25.   huart1.Instance = USART1;
    
26.   huart1.Init.BaudRate = 9600;
    & w* P# X; h& z: u4 c( i
27.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    
28.   huart1.Init.StopBits = UART_STOPBITS_1;
    , l# u( q: C0 k3 [) d
29.   huart1.Init.Parity = UART_PARITY_NONE;
    
30.   huart1.Init.Mode = UART_MODE_TX_RX;
    
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    6 s, ^3 V* A2 w
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
33.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    + g. l' E7 V" S! S$ K
34.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
35.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    9 J% w6 [2 y% R5 a" g, R
36.   {
    & w8 B+ c( f; [, B
37.     Error_Handler();
    4 J. B# Q( h) D9 D) m( R+ i
38.   }  
    ! N/ I2 F# R* I# j2 P+ F6 Z6 f9 b
39.         
    3 E( |7 q; o% ^) v+ O; M- [% q
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
41.   {
    
42.     Error_Handler();
    . W, z( O/ Y' a7 C" ]
43.   }
    # c2 ^5 W( o8 z7 s" L
44.         
    ' f6 x! {. f4 @' A2 h- }; c" t3 C. ^
45.         UartrxReady=RESET;
    % r* p- n5 _" w" S, N$ U
46.   /* USER CODE BEGIN USART1_Init 2 */
    
47.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    . Z' O, b2 z. O
48.   {
    
49.     Error_Handler();
    % J, y, X' }) K2 f/ H5 j
50.   }
    
51.         
    
52.   /* USER CODE END USART1_Init 2 */
    5 \. S; I/ F& w+ P) n
53. }

复制代码

. i  f7 j) b6 N" p4 n4 Y7 l从串口调试助手可以看只有接收的长度 RXBUFFERSIZE为10时，才触发接收回调函数。

' }' e4 U6 e- d/ d* Q$ q
7 n. p+ U& O2 P/ i* x2.1.2 编写空闲中断函数接收不定长
4 A2 \1 ^( t: D; F  sUSART1初始化：
* L7 f$ F9 c  Y1 M1 Z: X5 k. t* I* P

1. static void MX_USART1_UART_Init(void)
   5 c4 n* e0 d1 R
2. {
   6 n5 \4 B0 K* m' k; r6 v& R
3.   huart1.Instance = USART1;
   
4.   huart1.Init.BaudRate = 9600;
   
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   # C2 l5 `) ~$ ^/ x% o( T
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   $ V! U1 O- {8 x$ F
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    , a. I/ u' ~* a6 y
14.   {
    ( D5 k3 i2 S1 X# J0 g8 ^
15.     Error_Handler();
    
16.   }  
    - d: |& ?0 H- i; w' l
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    7 X/ W: n' S, S) B
19.   {
    & V/ n6 _; n1 n
20.     Error_Handler();
    $ A5 i8 m2 q, Z- b  j$ W- v' R+ L7 T% |
21.   }
    
22. 
    5 }1 ]. a) e1 F. H1 P5 }5 p
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
      v5 ^7 F: |/ [7 ?: x
24.   /* USER CODE BEGIN USART1_Init 2 */
    . T9 W5 F2 U6 b6 Z/ N6 m0 t
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    / R8 e, m& J" D( b" n' ?: w9 U- ]
27.     Error_Handler();
    9 R% `2 S6 Z2 ^7 N; C: a6 t6 w
28.   }
    . g) O3 }  y+ R) y" c* o
29.         
    
30. }

复制代码

7 `. ^# Q3 {7 ?" A  i空闲中断函数：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   9 m) H$ Y! R* y9 O
3. #define RXBUFFERSIZE                    30
   , V( _: y( L, g  g
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
6. {
     y4 q2 p) L' T5 w
7.     HAL_UART_DMAStop(&huart1);
   
8. 
   - p0 k; M  A- Z4 N" G
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   8 P) Z% |+ l# M4 z4 b6 s
10. 
    5 ]3 M) G# |3 h: ]4 M' y$ e
11. 
    7 x/ c  x+ {! y: _7 d! B( J# ^5 o
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    
13. 
    
14.     memset(aRxBuffer,0x00,data_length);
    
15.     data_length = 0;
    
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    1 T2 k8 D* A& k0 ?& f5 e
17. }
    
18. 
    
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    3 o5 H  y0 G3 a6 ~) C  H, C
20. {
    : t0 F6 c; _# Y
21.     if(USART1 == huart1.Instance)
    5 T8 O# G# J3 o2 r$ J* f
22.     {
    ' J( J: k) d3 g% p
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
24.         {
    
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    ! i" L& ^; ]3 H2 E! W' i4 A. p
26.             USAR_UART_IDLECallback(huart);
    
27.         }
    
28.     }
    
29. }
    
30. 
    
31. /**
    
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    ' _+ y- t. e+ X5 F5 Q8 u8 z$ t) r
33.   */
    
34. void USART1_IRQHandler(void)
    # J0 {8 O9 N2 J* W; i
35. {
    
36.     HAL_UART_IRQHandler(&huart1);
    
37.     USER_UART_IRQHandler(&huart1);
    
38. }

复制代码

: k0 L7 S/ ~6 Y1 \6 e6 b! R3 _8 {可实现不定长的接收！
+ z! z% h) [3 z8 P  t
# s2 V& t/ X! K) o6 ?' d

0 b. z& z' x9 m 注意：
在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。

三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
# W! Y0 `  _) ^) N; k$ t使用原因：

        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。

        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖

$ {6 a) u/ d" y( G+ v+ B& g① fifo头文件：

1. #ifndef        __FIFO_H_
   
2. #define        __FIFO_H_
   
3. 
   7 z3 o% {( T4 g) i0 v1 y9 b
4. #pragma pack(4)
   
5. typedef struct FIFO_Type_STRU
   
6. {
   " r4 P: z: R7 a  s' u8 u
7.         unsigned int                        Depth;                        // Fifo深度
   
8.         volatile unsigned int        Head;                        // Head为起始元素
   9 z+ ^$ _9 w( D/ E3 B0 S
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    7 G9 h& d' S9 A. M6 ~
12.         void                                        *Buff;                        // 缓存区
    6 E5 Q' [) Y+ V7 V0 |
13. }FIFO_Type;
    
14. #pragma pack()
    
15. 
    
16. /********************************************************************//**
    * L: C5 s& I& ~6 f& r
17. * @brief       FIFO初始化
    
18. * @param[in]   pFIFO: FIFO指针
    ( P% L- b8 p2 v3 {+ N) o* d+ t
19. * @param[in]        pBuff: FIFO中缓存
    
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    / I9 P8 |3 e2 u# R1 c0 v
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    
23. *********************************************************************/
    ' w  W. P) ~7 |% h/ u) f
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    
25. 
    
26. /********************************************************************//**
    + I; n0 n3 R" J  k7 o
27. * @brief       向FIFO添加一个元素
    
28. * @param[in]   pFIFO: FIFO指针
    
29. * @param[in]        pValue: 要添加的元素
    
30. * @return      1-TRUE or 0-FALSE
    3 Z* o7 W9 M( A2 M
31. *********************************************************************/
    . W+ r; O0 z' ]7 p7 a
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    " U  K9 ^1 h* d3 B4 E) m, p) i, i
33. 
    0 w3 l% {1 I  f7 o
34. /********************************************************************//**
    
35. * @brief       向FIFO添加多个元素
    
36. * @param[in]   pFIFO: FIFO指针
    & g3 D/ Y* a& F9 ]9 {% d
37. * @param[in]        pValues: 要添加的元素指针
    
38. * @param[in]        bytesToAdd: 要添加元素的长度
    $ w/ a1 r& \! X/ p7 N
39. * @return      实际添加的元素个数
    
40. *********************************************************************/
    & @5 `, l$ k8 t
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    
42. 
    ! K3 n* X1 j. \; `8 Q
43. /********************************************************************//**
    
44. * @brief       从FIFO读取一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 存放要读取的元素指针
    ; I8 K! B+ C5 G
47. * @return      1-TRUE or 0-FALSE
    6 I& f; K4 m: I0 S1 `+ a
48. *********************************************************************/
    + F3 V* v9 j  [% g& J" Y5 d6 T
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    4 k6 l' i. |  Q. P. v
50. 
    # Q# @! U) y9 y
51. /********************************************************************//**
    
52. * @brief       从FIFO读取多个元素
    6 m& h" D/ ^. {
53. * @param[in]   pFIFO: FIFO指针
    ! F: J$ ~+ ^  J; c: w( v" V
54. * @param[out]        pValues: 存放要读取的元素指针
    8 X/ E# `( R& n( }. v
55. * @param[in]        bytesToRead: 要读取的元素长度
    7 q$ @  h. l, r1 x" M
56. * @return      实际读取的元素个数
    
57. *********************************************************************/
    $ `+ t  I9 v% z4 Z
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    ; ^/ m; p4 s; C" w  v8 j, k5 ]' ?
59. 
    4 t  p  }4 H; \8 S7 m% \( ~
60. 
    4 N$ @3 v/ _5 y; K9 g
61. /********************************************************************//**
    & p4 z7 b" a, @1 _7 I( W
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    
64. * @return      None
    4 x+ T/ a& c  a3 t% G! s: h) s
65. *********************************************************************/
    + O1 n& t4 H0 L: [9 F7 `3 @- L
66. void FIFO_Clear(FIFO_Type *pFIFO);
    
67. 
    : ]+ B3 T0 K% ]' I' [7 C
68. 
    
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    
70. 
    
71. #endif

复制代码

② fifo.c程序主体
( [" e* u7 A) \" z4 U5 T$ J

1. #include <string.h>
   
2. #include "fifo.h"
   
3. 
   
4. 
   $ f5 |+ A* X% x8 `! l
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   
7. * @param[in]   pFIFO: FIFO指针
   % m1 j, d6 J2 i$ t. I
8. * @param[in]        pBuff: FIFO中缓存
   7 K  g6 A- }2 F0 c5 }
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   
10. * @param[in]        depth: FIFO深度
    
11. * @return      None
    
12. *********************************************************************/
    / ?" ^- z. }4 f
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    1 |7 z' C7 G2 O
14. {
    ( {- T' u) A2 g3 b0 I1 \
15.         pFIFO->Buff = pBuff;
    
16.         pFIFO->ElementBytes = elementBytes;
    & ^# x* j8 Q, O# W2 |
17.         pFIFO->Depth = depth;
    
18.         pFIFO->Head = 0;
    - r' u5 U) `+ O$ J' }. ]/ Y
19.         pFIFO->Tail = 0;
    4 o* [2 k/ L. O' b/ i. a4 @
20.         pFIFO->Counter = 0;
    
21. }
    ' @7 {+ D) S" m8 r8 y0 i
22. 
    5 a, d' G/ O& p3 V) x6 n9 B3 E
23. /********************************************************************//**
    1 E: n  m7 Z2 n0 b8 b8 E
24. * @brief       判断FIFO是否为空
    
25. * @param[in]   pFIFO: FIFO指针
    $ z" \( G9 j2 P. E  ]& L% X
26. * @return      1-TRUE or 0-FALSE
    + _9 u6 X5 b! Y9 d  l0 V% Q. D4 b0 s
27. *********************************************************************/
    ) a0 g. f" i* G" b
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    ; T+ |' h$ R7 I  g
29. {
    4 f7 k+ e4 L! X, x8 e
30.         return (pFIFO->Counter == 0);
    
31. }
    0 N! s7 e9 }& a, C8 i3 W+ V! ~
32. 
    
33. /********************************************************************//**
    3 }# g; a$ F6 P
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    
36. * @return      TRUE or FALSE
    
37. *********************************************************************/
    
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    
39. {
    
40.         return (pFIFO->Counter == pFIFO->Depth);
      x7 c' G' \# ^' @/ D4 \; N7 S
41. }
    2 q9 ^0 w0 g% `" T* N, C: i, {
42. 
    
43. /********************************************************************//**
    
44. * @brief       向FIFO添加一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    . E, \+ u# x: `
46. * @param[in]        pValue: 要添加的元素
    - C' ?% B( E  V! c9 G# [- b
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    1 x3 \: W& @& N/ V+ H( @
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    ! u2 g4 }7 |* ?  N4 s( I: e  S- P
50. {
    ! u" b* Z( {( j; c0 |
51.         unsigned char *p;
    
52. 
    
53.         if (FIFO_IsFull(pFIFO))
    
54.         {
    $ M8 ~1 H" g1 e/ J! [8 _( z, N
55.                 return 0;
    
56.         }
    
57. 
    / j$ a' c6 P. v  a
58.         p = (unsigned char *)pFIFO->Buff;
    
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
    ! P  \  o, m- f" c1 X7 V; n8 Q! k
60.         
    
61.         pFIFO->Tail ++;
    
62.         if (pFIFO->Tail >= pFIFO->Depth)
    ! o* E+ J+ C; a3 L" A  y; ^# K  N: L
63.         {
    * Y5 h' Y! D1 P
64.                 pFIFO->Tail = 0;
    
65.         }
    
66.         pFIFO->Counter ++;
    
67.         return 1;
    
68. }
    
69. 
    
70. /********************************************************************//**
    
71. * @brief       向FIFO添加多个元素
    3 a- J0 @3 e6 k, N0 f/ V
72. * @param[in]   pFIFO: FIFO指针
    $ T# x( `7 [3 d/ e3 V+ \  U! {
73. * @param[in]        pValues: 要添加的元素指针
    . n; R% e% I# Z
74. * @param[in]        bytesToAdd: 要添加元素的长度
    
75. * @return      实际添加的元素个数
    
76. *********************************************************************/
    8 U, l! W3 ^$ h' b8 U
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    
78. {
    6 d/ R( `' m0 C, I) v. w+ X
79.         unsigned char *p;
    
80.         unsigned int cnt = 0;
    6 g+ m% A( T2 n
81. 
    
82.         p = (unsigned char *)pValues;
    
83.         while(bytesToAdd --)
    
84.         {
    6 x( |2 E4 }0 H/ c/ s
85.                 if (FIFO_AddOne(pFIFO, p))
    + o" |7 Y; G4 O8 b
86.                 {
    
87.                         p += pFIFO->ElementBytes;
    & ]- h; ]; s- ?* L. z* X/ P
88.                         cnt++;
    
89.                 }
    2 o+ B$ `! _5 }! p9 H
90.                 else
    
91.                 {
    . k! v9 U& a6 g$ [3 k( C
92.                         break;
    
93.                 }
    
94.         }
    & U% z3 n$ _/ M# l+ n0 x' s: n. C
95. 
    * T7 v7 ^; V1 l
96.         return cnt;
    
97. }
    + ~& I& {$ v+ V* l" E
98. 
    
99. /********************************************************************//**
    / r. U- F+ b2 F$ S
100. * @brief       从FIFO读取一个元素
     / c3 f& W: g; `6 G( @% X- _) g" D
101. * @param[in]   pFIFO: FIFO指针
     ) }# M3 @9 q4 q% E
102. * @param[in]        pValue: 存放要读取的元素指针
     / V5 Q4 r6 y1 d
103. * @return      1-TRUE or 0-FALSE
     
104. *********************************************************************/
     
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     
106. {
     ! j8 B. Z- R3 C* @$ o. F, d
107.         unsigned char *p;
     / D; E5 P7 y: m
108.         if (FIFO_IsEmpty(pFIFO))
     4 c+ Y  N- r# I% M# Q9 o
109.         {
     
110.                 return 0;
     
111.         }
     
112. 
     $ X) J4 G) }- s" S  X
113.         p = (unsigned char *)pFIFO->Buff;
     & `6 R* c. S7 e0 Z( F% w* b6 x
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     
115. 
     - g& V+ n! f/ @6 n4 D
116.         pFIFO->Head ++;
     
117.         if (pFIFO->Head >= pFIFO->Depth)
     2 c' E: Q, p* F" }: b# m* ^  s
118.         {
     1 @! x: s/ u9 s/ e1 |; H8 y
119.                 pFIFO->Head = 0;
     
120.         }
     
121.         pFIFO->Counter --;
     ) J% w, R( Z! |& i0 e9 j' r7 F  g
122. 
     
123.         return 1;
     
124. }
     4 \9 C$ y7 N7 }5 A) f# q2 c
125. 
     & k, z2 W0 B1 K/ X# z( a& a
126. /********************************************************************//**
     
127. * @brief       从FIFO读取多个元素
     
128. * @param[in]   pFIFO: FIFO指针
     
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     ! w$ I/ R7 g8 R$ Q
131. * @return      实际读取的元素个数
     
132. *********************************************************************/
     & B/ A- x7 N* Q5 N. u7 b) h
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     
135.         unsigned int cnt = 0;
     9 n6 L& }. n4 X1 Q9 [9 J5 D
136.         unsigned char *p;
     
137. 
     4 g4 L( y- ]  K6 Z+ ]
138.         p = pValues;
     
139.         while(bytesToRead--)
     ! w3 g$ {! {& N' a6 @3 I1 N' B# {
140.         {
     
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
       W5 E4 P, t$ G% c; q% F. ]
143.                         p += pFIFO->ElementBytes;
     5 R- r, s3 d. d% @: T
144.                         cnt++;
     
145.                 }
     7 a2 a% F( n6 h5 T2 d% C) u% H( h
146.                 else
     ) h8 e/ z& U! {1 `6 u
147.                 {
     5 h' ^; @3 i+ @/ p4 D: e3 i8 V8 E
148.                         break;
     : N0 E( P4 n- d$ {  y" k# X7 a' ~0 }
149.                 }
     ! s5 D9 U: i* i* ~
150.         }
     
151. 
     : I) I& D, S+ m& u2 E
152.         return cnt;
     # w- @1 B: q8 y; W% g
153. }
     
154. 
     
155. /********************************************************************//**
     
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     
159. *********************************************************************/
     3 Y% |0 q& f# [5 ^; b) k
160. void FIFO_Clear(FIFO_Type *pFIFO)
     1 G, Y* B6 [( H7 ?' ^) O
161. {
     
162.         pFIFO->Counter = 0;
     3 T1 A$ H  H& {7 D
163.         pFIFO->Head = 0;
     
164.         pFIFO->Tail = 0;
     ) I/ |( P  e% H1 b4 h' m, J3 ?* \: A
165. }

复制代码

5 |- E! [0 J' A4 U  I ③ 串口初始化
  y! `/ M9 \/ A7 J5 y

1. static void MX_USART1_UART_Init(void)
   * X2 ~) o5 K# k  _6 |5 X
2. {
   
3.   huart1.Instance = USART1;
   + {: B* c- r) w: Z
4.   huart1.Init.BaudRate = 9600;
   
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   " G  c$ T+ E$ h: y8 r- n  e
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
      g) X9 w  t- V( Z4 J. Y6 F. i
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    . P' d2 I* Y# ~- c( P! F6 n; u
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    
14.   {
    
15.     Error_Handler();
    + W- C+ d6 W, v! N
16.   }  
    & z  P' H( t0 K' F, l
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    $ m5 K  o$ }+ ~. i
19.   {
    " |' H6 _& w  V
20.     Error_Handler();
    ' x$ e) L, d( j
21.   }
    
22.         
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    : E' q2 U5 l3 D5 R
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
      |0 e/ }4 C  x* t# n2 s
27.     Error_Handler();
    
28.   }
    
29.         
    8 g4 d! l8 K4 y& ]
30. }

复制代码

7 c: w8 {/ e  Q& O ④ 接收空闲中断

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
2. {
   ! V' Z4 A; h; ^8 Y5 y1 j& F3 I5 C
3.     HAL_UART_DMAStop(&huart1);
   7 X( w, @4 k# Q! P2 G) k
4. 
   
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   " M! J$ d, E& m$ C5 y. N, S& I
6.         
   . }/ Y1 s6 A1 M* s! F. D
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   
8.     data_length = 0;
   2 a" Z( {  I. A  V1 v) C( M
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   8 c( |' a! O$ r2 {+ f9 i0 z  t
10. }
    
11. 
    8 K, P" ]4 a  F# Y! ~0 _0 u
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
13. {
    ( Z* |8 L/ I' i- S7 {" \
14.     if(USART1 == huart1.Instance)
      }( X3 f5 Q" ?5 W* S# q. X% r
15.     {
      g! O3 P* o. z# l. i% h/ Z
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    - r" T2 }9 j7 C; W8 I9 `$ C: {
17.         {
    9 P" A4 n& Y  s, K
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
19.             USAR_UART_IDLECallback(huart);
    6 G/ {; D4 ?; e3 c
20.         }
    ! M: L: G6 k6 Q* t
21.     }
    3 I" f! s9 @* k+ t2 y- H2 Q
22. }
    ) H2 u4 I3 S. F# P/ X( R
23. 
    
24. /**
    
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
26.   */
    
27. void USART1_IRQHandler(void)
    ) R- C8 p1 A: u" V
28. {
    
29.   HAL_UART_IRQHandler(&huart1);
    
30.   USER_UART_IRQHandler(&huart1);
    
31. }

复制代码

⑤ 主函数调用：
: H9 s+ T2 c* h4 Z" T

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   - O# W. X0 ~$ N% D' u# {; b# J
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   5 a% V& A0 C$ i+ E
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   8 l- S1 p& u9 ?  }: s: V2 r
5. 
   " J" j- z: o  W- ^; e% r- x
6. 
   ; ~7 }/ u* ]  a+ M* a* }. T
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   3 f( t1 g2 r' t0 K
8. 
   . _3 z* r' X* R/ V9 R% T7 a
9. /* Buffer used for reception */
   
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    
11. 
    
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    
13. FIFO_Type        fifo;
    - h& k) R# V/ P3 B9 S' }
14. FIFO_Type        *pfifo;
    
15. 
    
16. int main(void)
    
17. {
    
18.   /*此处省略硬件初始化*/
    + A# v( I2 U; m' D: R' Z4 c
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    # p- s6 P, V  A- D/ C5 m
20.   {
    $ W( h6 O# z5 q& E# Y* I8 u
21.     Error_Handler();
    
22.   }
    ( I4 q, f# Y/ \1 Y7 l
23.         
    # l2 X' A+ b! O7 J% \
24.   pfifo = &fifo;
    
25. 
    
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    - ?  m/ e7 |) M7 Y* r# R2 r! i
27. 
    
28.   while (1)
    ( f% q2 g4 C& `4 b  h7 {
29.   {
    5 T, I7 z% T( U- n9 Q$ O
30.         /*一次接收的缓存，重新发送*/
    $ t7 c; {" O( O3 l' O+ p
31.                 if(!FIFO_IsEmpty(pfifo))
    , [# M+ L! j  \+ {- J
32.                 {
    
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    3 P" k- Z4 a+ Z6 w
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    + Z5 Z3 K- [$ J. X& U  H
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    # _( w: W1 C  |7 H9 h$ D
37.                 }
    % {5 v0 l0 n8 u& |) Q  g2 k
38.   }
    ) O2 E5 M9 `  R/ p3 b
39. }

复制代码

# R5 y% q5 @2 _! K' n9 S测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！
* a. G% s& d+ h2 x/ b) r! Y- Y$ G9 O
7 X9 v. F+ Z" U- p/ u$ Y

* F4 s  Z! A( g' T6 q) M8 Q问：关于 stm32 HardFault_Handler问题处理？
0 y1 K( m& m6 `3 }; N+ h. \" F6 \5 A
% r* c/ ?4 E; I2 Y0 r) k$ ^; UANS：
3 K3 h1 c, v: Y2 P
        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，
- W& b* f$ b$ I' ]- N+ C

; U/ J5 Y6 o! V" i

1 A( ^1 B0 v8 [$ B( v  C' f 最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！
8 o$ X3 R8 K! p9 {( l

1. pfifo = &fifo;

复制代码

% C5 y- {6 U' O" s6 @' [. S
. x1 W/ C, \  m& M4 k. E
  F, }, V3 `( F, ^' \