一、STM32CubeMX开发
( k7 q' R# x7 @1.1 新建工程
file -> new project

选择芯片-> stm32 core内核         
) A1 y. f# m8 r8 a' ]
: I( _  H6 Q% ]& v. [                   stm32 series 系列

                   stm32  line
$ D0 W$ {9 r- F
                   stm32  package

选择芯片根据自身需求去选择，目前该项目是stm32f0系列
' d3 ~' V$ g$ `3 C" B
9 e0 s& l4 Y5 ?8 H" E/ v4 L                    stm32 core内核         M0

                   stm32 series 系列      F0
, g% c; o8 r$ \! q' h
( r1 _' u2 R5 f7 l1 \+ {                   stm32  line                 F0X1

                   stm32  package         TSSOP 20
8 s3 B6 ]4 r( s0 v, _* i( D8 p
, p$ {1 S* x# p* q& a 1.2 配置 USART1
配置 USART1 的模式为 Asynchronous，即异步串口模式
- ~$ N! Q/ |+ M) q# ?4 t  x
+ p! P5 [3 h: T! l. ~/ t' D

" ?9 c  ^/ j: c2 i- J1 Z
1.3 配置串口参数
根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1
0 r0 ^6 I7 I5 K7 Y! O, t

4 q- a8 ?" [; C! |' T) ~; v 1.4 设置DMA

6 n: }# w' D1 ?" J+ {# i

( T& n2 A) t# E
1 k2 i8 ?$ A7 V0 A) P$ A 1.5 添加串口中断
4 @0 [) n7 M% N0 m9 u, {

- e* v; @! Y7 I+ x
1.6 生成源代码。
' m1 V; A, }# t" M在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。

4 v  e& ], B" e

, T: S3 ~7 o! Q$ w2 A9 F2 u4 x生成代码完成后可选择打开工程。

+ m& ~. j# J% h二、代码部分
2.1  接收中断处理
( {1 \; [. r8 ~. l% j! Z2.1.1 接收固定长度：（舍弃）
5 V) Q# Q& Q$ H% b1 G) }# f7 u0 }8 F( B只有接收缓存到固定长度才会触发中断
串口接收回调函数
, ^5 q$ m/ `7 F6 s" A
$ x7 {, }# n* ?' p: D" A$ x

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    10
   : R9 v* J' E: e$ h2 ~
4. 
   3 f! y4 f) i' @7 K$ T
5. 
   
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   
7. {
   4 ]+ ~2 N  ~, q1 t: u+ F
8.   /* Set transmission flag: trasfer complete*/
   " }) k3 e% w  R3 q: J
9.   UartrxReady = SET;
   : V9 z& G! W( J( V. d# W) B- s
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    2 N3 W. W& }) B* Z6 q4 [
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    : A4 f; I4 c4 U' ^$ |1 w  w1 B
13. 
    % g8 O0 }( z9 D+ b1 N7 a/ o+ g
14. }
    
15. 
    
16. void USART1_IRQHandler(void)
    4 t: U. X& v* l) }  [+ a" o
17. {
    
18.   HAL_UART_IRQHandler(&huart1);
    ! _0 v, f5 j* k  D7 L& c7 ]4 L
19. }
    
20. 
    
21. 
    
22. static void MX_USART1_UART_Init(void)
    , J; e' x( u1 T6 ]: t7 V& k
23. {
    & I) g5 A/ Q. v; s! M
24. 
    
25.   huart1.Instance = USART1;
    5 Q7 s9 `0 u# C/ _0 }8 A  m
26.   huart1.Init.BaudRate = 9600;
    8 H3 y4 b; m% U, x2 M# U9 @
27.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    6 d" F' @% U- g; j( F5 z
28.   huart1.Init.StopBits = UART_STOPBITS_1;
    
29.   huart1.Init.Parity = UART_PARITY_NONE;
    1 M) ]* e0 A: U7 U) C/ e6 j5 Z
30.   huart1.Init.Mode = UART_MODE_TX_RX;
    
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
33.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    % g$ U# [+ a/ m0 @* }. n' q$ j
34.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    1 E/ c6 }- C6 c! H9 J! _
35.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    ; Z, r1 C* N2 E. {0 s+ I% X& `# d
36.   {
    2 {# \3 u, B2 ?$ j  ?1 a
37.     Error_Handler();
    
38.   }  
    
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    4 X! B$ J2 R8 `  _  c" U
41.   {
    
42.     Error_Handler();
    
43.   }
    # R( W3 g( c9 i% o0 ]+ Z' d. b
44.         
    ' X! M9 J, c+ p  F
45.         UartrxReady=RESET;
      j  [% a" |  J9 g7 [4 o
46.   /* USER CODE BEGIN USART1_Init 2 */
    
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 */
    
53. }

复制代码

从串口调试助手可以看只有接收的长度 RXBUFFERSIZE为10时，才触发接收回调函数。
5 `; n: i% A$ o! }( ~; h. E
" U6 x8 H6 g, h9 f/ z) M' z

" S1 j5 T6 d: G& H- V) B
2.1.2 编写空闲中断函数接收不定长
" S4 |+ ?- F5 g0 f2 {  a' i0 UUSART1初始化：
5 u: ^4 r8 J2 k( u! L0 O! `# _. G

1. static void MX_USART1_UART_Init(void)
   ; Y& b% x4 f% q& i
2. {
   
3.   huart1.Instance = USART1;
   
4.   huart1.Init.BaudRate = 9600;
   
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   " u# ^( q% ~8 f5 e. K! E+ D& j/ Y
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   8 X( h8 x# B' P( P$ G# E
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)
    % P7 ~$ I" t8 ~; [
14.   {
    
15.     Error_Handler();
    " D. i& X) a1 ~3 q
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    / N$ P! W3 W# l& b
19.   {
    ' W% X% I7 @5 V+ g/ w* ]! A6 \
20.     Error_Handler();
    
21.   }
    
22. 
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    0 u7 ~3 h$ o7 o4 k
24.   /* USER CODE BEGIN USART1_Init 2 */
    
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    * {. J1 U& u, \1 A4 e$ @4 B
27.     Error_Handler();
    
28.   }
      g! S0 F! b5 S
29.         
    7 l' q% S: t( n+ M
30. }

复制代码

空闲中断函数：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    30
   
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
6. {
   % J1 E; I5 i$ y' k  J9 h
7.     HAL_UART_DMAStop(&huart1);
   7 T8 f: {0 [/ P
8. 
   
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   : k7 b5 A5 P( P- H
10. 
    " q/ J. W  y* W. f3 E
11. 
    4 V$ {/ l( ^0 d
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    3 D% ?3 o# E' }% J& C. L; ^5 `
13. 
    
14.     memset(aRxBuffer,0x00,data_length);
    
15.     data_length = 0;
    
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    
17. }
    
18. 
    1 m3 w+ i: B* N' S- d
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
20. {
    
21.     if(USART1 == huart1.Instance)
    3 y  w- i' T" x. B- c) d( R7 @# C
22.     {
    
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
24.         {
    
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    " p3 V. J. q8 ~  _& k" t
26.             USAR_UART_IDLECallback(huart);
    
27.         }
    
28.     }
    
29. }
    
30. 
    $ V" a- t- j. _# k
31. /**
    + R! V! b4 F; t0 _: M% W9 I6 ~
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    3 B& ~$ ^2 E! ~# O
33.   */
    4 N* m$ L, X8 E$ B
34. void USART1_IRQHandler(void)
    ' R8 s% e' k# J. o! V
35. {
    
36.     HAL_UART_IRQHandler(&huart1);
    0 T6 K; A2 \+ D! i
37.     USER_UART_IRQHandler(&huart1);
    
38. }

复制代码

  |5 X# D" t2 r5 {) [可实现不定长的接收！
; B! V4 @# N9 i

( X/ m) o+ @& R7 u
5 Z9 J4 `- M5 S* W+ Q$ [$ G 注意：
在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。

: @+ N0 a1 i# u  T1 z8 k" T 三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
% e: f" [: ~. ^/ Q& V使用原因：

( ?  P" s% [7 G( r/ W( d5 U        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。

& I1 Q# g- U5 w8 P! v; M" j9 J        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖

① fifo头文件：
& F2 U2 G# \. M9 \

1. #ifndef        __FIFO_H_
   , x8 Y! E# D/ E& o) {2 j
2. #define        __FIFO_H_
   
3. 
   
4. #pragma pack(4)
   
5. typedef struct FIFO_Type_STRU
   / [  U" k0 G- P, k: ]; R* _
6. {
   
7.         unsigned int                        Depth;                        // Fifo深度
   
8.         volatile unsigned int        Head;                        // Head为起始元素
   
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    
12.         void                                        *Buff;                        // 缓存区
    / k$ }5 y- i, k! \) ]/ p% ]. ?+ m* M* ~
13. }FIFO_Type;
    
14. #pragma pack()
    ( }- M+ o2 t5 T- X
15. 
    
16. /********************************************************************//**
    3 A: o/ w. u( V: M4 Z1 g" @
17. * @brief       FIFO初始化
    % @, P2 Y: ]  y- x& N/ {! D
18. * @param[in]   pFIFO: FIFO指针
    , o* Y1 Q! O# j. N' x
19. * @param[in]        pBuff: FIFO中缓存
    
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    , G+ M* l. ?0 V' ^; ]( K
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    ! Q! R; m" H& k1 H# v. S
23. *********************************************************************/
    ' E5 j, E/ @* R8 ^0 n& W
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    # o4 S- h; x9 C$ r5 x2 v* D
25. 
    ' v. I# u6 x: x# j. M
26. /********************************************************************//**
    $ w' L; }* i/ z7 p& [
27. * @brief       向FIFO添加一个元素
    
28. * @param[in]   pFIFO: FIFO指针
    0 O8 k) g+ K! J  j& ^) ]' d
29. * @param[in]        pValue: 要添加的元素
    
30. * @return      1-TRUE or 0-FALSE
    4 ?! ?4 c* W$ b, P; y- W
31. *********************************************************************/
    
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    
33. 
    5 u+ W9 }6 [% ~) j$ Z! T
34. /********************************************************************//**
    
35. * @brief       向FIFO添加多个元素
    6 e- s+ F: P" r/ r9 `5 R; n
36. * @param[in]   pFIFO: FIFO指针
    
37. * @param[in]        pValues: 要添加的元素指针
    ) `' @3 U  j1 N, A" Y7 W4 c
38. * @param[in]        bytesToAdd: 要添加元素的长度
    & E( ~8 p7 M: |. ]! X* h
39. * @return      实际添加的元素个数
    6 E5 m/ n9 p/ ~2 E! _
40. *********************************************************************/
    1 ~" P: ?  c4 P) a0 r0 F" t2 W
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    
42. 
    
43. /********************************************************************//**
    
44. * @brief       从FIFO读取一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 存放要读取的元素指针
    ( G, d/ W5 o& a3 ~
47. * @return      1-TRUE or 0-FALSE
    , q/ m$ r) p6 }
48. *********************************************************************/
    0 _6 Z6 q4 B% X: A9 v% ~# c
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    ! i0 M  Z4 D$ g* ~: e7 S! f+ p
50. 
    4 q2 u$ z( y+ F
51. /********************************************************************//**
    8 F/ a) \8 c: K. |4 h4 q4 ~
52. * @brief       从FIFO读取多个元素
    
53. * @param[in]   pFIFO: FIFO指针
    
54. * @param[out]        pValues: 存放要读取的元素指针
    
55. * @param[in]        bytesToRead: 要读取的元素长度
    
56. * @return      实际读取的元素个数
    
57. *********************************************************************/
    
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    
59. 
    
60. 
    & G! z$ G! |* M2 E! F- O3 i
61. /********************************************************************//**
    
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    
64. * @return      None
    
65. *********************************************************************/
    5 |" V! A0 w7 z0 V
66. void FIFO_Clear(FIFO_Type *pFIFO);
    4 y0 ?; e+ {% M* T5 ?
67. 
    
68. 
    
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    
70. 
    
71. #endif

复制代码

② fifo.c程序主体
* Y1 W. x* H% e% z( g
' b) U# J$ V) W$ V3 |

1. #include <string.h>
   , g& S9 I$ H. ?: G' K! R
2. #include "fifo.h"
   
3. 
   
4. 
   ) Q! S2 N  E- I# E5 f0 }$ \
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   
7. * @param[in]   pFIFO: FIFO指针
   0 N; N+ \* f. t; ^6 X; U
8. * @param[in]        pBuff: FIFO中缓存
   
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   / d( Y7 m# O1 a
10. * @param[in]        depth: FIFO深度
    - U) D) P& s( j3 h# D0 e
11. * @return      None
    / m1 T+ F% @# A, N5 @0 u3 `
12. *********************************************************************/
      I- X+ S7 b% D" {& t+ i7 n
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    
14. {
    / M; X/ N" S3 P" ]; P
15.         pFIFO->Buff = pBuff;
    
16.         pFIFO->ElementBytes = elementBytes;
    
17.         pFIFO->Depth = depth;
    
18.         pFIFO->Head = 0;
    / `. a: ]* T8 j$ o, D# r. u
19.         pFIFO->Tail = 0;
    0 Q+ e" S! b) g
20.         pFIFO->Counter = 0;
    0 C) a7 W& z( u- ]* q
21. }
    . G4 ^" g1 ~4 A, ?0 o
22. 
    
23. /********************************************************************//**
    
24. * @brief       判断FIFO是否为空
    " B7 [; [# A. S7 X6 J
25. * @param[in]   pFIFO: FIFO指针
    * ^% K" H: ?- C- P6 N9 N7 r
26. * @return      1-TRUE or 0-FALSE
    : g$ O8 w( E- {5 F$ i
27. *********************************************************************/
    1 I% N5 @* l0 y4 U
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    & e* ]$ @/ l# e2 c6 c$ m- o# x  y
29. {
    ; N* n! b7 T' i  |
30.         return (pFIFO->Counter == 0);
    ( n. g1 l7 p9 J+ }: _- L
31. }
    / c8 \5 H0 t0 B/ g; @
32. 
    
33. /********************************************************************//**
    / U( u- D3 C5 Z: |2 @( ~6 \+ d
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    " e4 W4 [6 f4 z& O9 D
36. * @return      TRUE or FALSE
    : t0 s3 v' B% E  Q. R: l" z4 k
37. *********************************************************************/
    
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    
39. {
    
40.         return (pFIFO->Counter == pFIFO->Depth);
    
41. }
    * o/ [, ^8 J4 f& P* x/ ~
42. 
    " ^( N* E  |. S) l1 n
43. /********************************************************************//**
    # v# T: ^9 b. x% D+ ]) T, a/ ]
44. * @brief       向FIFO添加一个元素
    2 [( [" e+ ?: k- g; E$ Y; {. d
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 要添加的元素
    & E$ `! Q2 ^9 y8 Y# d" f  C
47. * @return      1-TRUE or 0-FALSE
    & [9 t9 X  p  ]( _' w  b% X
48. *********************************************************************/
    
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    
50. {
    2 O6 e& ~9 ^8 c, t4 V
51.         unsigned char *p;
    
52. 
    
53.         if (FIFO_IsFull(pFIFO))
    ; N& j& }; i. {) v
54.         {
    
55.                 return 0;
    " ^  z$ G  D% Q: C! s" U& A
56.         }
    
57. 
    
58.         p = (unsigned char *)pFIFO->Buff;
    ! o" h0 B$ W7 q2 N: X& T+ o; \
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
      x4 `3 E9 L8 _& S" E" t
60.         
    
61.         pFIFO->Tail ++;
    - ^- D5 X' }3 x# C
62.         if (pFIFO->Tail >= pFIFO->Depth)
    
63.         {
    % Z2 M5 T+ C2 r  }2 r* R; }% m# Y  X
64.                 pFIFO->Tail = 0;
    % @8 W$ f7 t# s+ Z
65.         }
    
66.         pFIFO->Counter ++;
    
67.         return 1;
    
68. }
    # v7 Q2 }: O0 J. U2 _* K. c
69. 
    , |% @$ {# \0 C! r+ f  n* y$ {) G
70. /********************************************************************//**
    
71. * @brief       向FIFO添加多个元素
    " Y7 U/ l; e; M  o
72. * @param[in]   pFIFO: FIFO指针
    
73. * @param[in]        pValues: 要添加的元素指针
    ; L" L% N# c' z! K' ^: Z, {
74. * @param[in]        bytesToAdd: 要添加元素的长度
    
75. * @return      实际添加的元素个数
    . m6 k5 r  y6 U
76. *********************************************************************/
    ( O+ f* M& Y4 m% o
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    : \1 c$ O. y: }- F) q, d8 m! W
78. {
    
79.         unsigned char *p;
    - w1 Z5 p# D  l, S4 I. O
80.         unsigned int cnt = 0;
    
81. 
    
82.         p = (unsigned char *)pValues;
    - P! ]9 f# d" X7 ?; y" X
83.         while(bytesToAdd --)
    
84.         {
    
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    
87.                         p += pFIFO->ElementBytes;
    1 B2 J4 c2 ]- ]1 j3 l
88.                         cnt++;
    
89.                 }
    * z% A9 {3 w1 Y  [8 q8 |2 r6 I) L+ a
90.                 else
    
91.                 {
    
92.                         break;
    / p2 j" l& t! x) i
93.                 }
    
94.         }
    8 m/ b5 r1 N$ d" I% Q% H
95. 
    $ ~0 q$ e5 v) W1 i
96.         return cnt;
    " i: e' n2 I" \/ ~" w8 J
97. }
    , P% J1 T& r$ K- o2 i7 ]
98. 
    7 b' K! c1 ^; D) u' ^/ ]# a: Z
99. /********************************************************************//**
    
100. * @brief       从FIFO读取一个元素
     0 ^4 K" N) w, |7 v% z
101. * @param[in]   pFIFO: FIFO指针
     " C( V3 E2 _# z
102. * @param[in]        pValue: 存放要读取的元素指针
       K6 }9 Q; |! S& `
103. * @return      1-TRUE or 0-FALSE
     " C# V$ {7 \; D3 \- C8 c  i
104. *********************************************************************/
     
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     
106. {
     / N# N1 M3 g) ^
107.         unsigned char *p;
     
108.         if (FIFO_IsEmpty(pFIFO))
     ( [3 W4 ^: a& X, R, \$ l, m
109.         {
     
110.                 return 0;
     ; f: F' |  [+ I0 h) l  E
111.         }
     - _& e) a  D+ l/ R
112. 
     $ b  Q) E  l4 p8 v3 x% P: h
113.         p = (unsigned char *)pFIFO->Buff;
     + T" O) F& i1 |/ L3 W
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     
115. 
     $ O9 T9 v) m' e$ K3 u, X
116.         pFIFO->Head ++;
     
117.         if (pFIFO->Head >= pFIFO->Depth)
     . Y3 n1 b. e' Q+ U1 T8 L
118.         {
     
119.                 pFIFO->Head = 0;
     1 Z; M7 N% {1 j' [* u" ^' f$ Z
120.         }
     
121.         pFIFO->Counter --;
     2 }8 p! U6 O2 E% g7 _4 a2 ~$ j
122. 
     
123.         return 1;
     
124. }
     0 p" e  Z. L' `# {# u4 X, l
125. 
     6 r& m2 B- C6 E( ^6 P1 {
126. /********************************************************************//**
     + d3 Y9 A8 L: G7 }, \* m
127. * @brief       从FIFO读取多个元素
     & u+ T0 _4 m6 h; C/ P
128. * @param[in]   pFIFO: FIFO指针
     
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     
131. * @return      实际读取的元素个数
     1 ?: i  o! ~/ w$ U! j1 p
132. *********************************************************************/
     
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     . V: k6 `" [/ W5 ?, |$ H. W' y
134. {
     , C: P* V! L( j* \/ w
135.         unsigned int cnt = 0;
     2 j+ O& ~0 E; ]. O$ }* [
136.         unsigned char *p;
     7 U* h# k7 Z5 F9 A
137. 
     0 n. E8 ^5 Z/ p. p
138.         p = pValues;
     6 G# N& \( @3 C4 L
139.         while(bytesToRead--)
     
140.         {
     7 A6 J/ @0 |! B. O* x+ ~0 }
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
     
143.                         p += pFIFO->ElementBytes;
     " v. o4 }' A) q& u# b, g2 v
144.                         cnt++;
     + K& z' `' A) T, i0 P
145.                 }
     ! }+ g% {) o. B9 C7 ]
146.                 else
     / W% D; _4 B( ?4 z; P; z( L
147.                 {
     
148.                         break;
     8 N0 P/ P$ p' E- a) N2 V3 K9 V
149.                 }
     
150.         }
     
151. 
     
152.         return cnt;
     
153. }
     
154. 
     
155. /********************************************************************//**
     , Y$ ~3 L5 Q% A% E5 O
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     . m8 s# F1 ?% E) ~" ?. m
158. * @return      None
     
159. *********************************************************************/
     
160. void FIFO_Clear(FIFO_Type *pFIFO)
     
161. {
     + ~1 y' F7 o1 ^: F0 H% X  ]
162.         pFIFO->Counter = 0;
     
163.         pFIFO->Head = 0;
     
164.         pFIFO->Tail = 0;
     , v) @2 E5 M5 o) u
165. }

复制代码

4 W! D5 ], ^3 y/ u7 Y6 x) d ③ 串口初始化
: L1 O8 Y3 m1 {9 x+ I* S

1. static void MX_USART1_UART_Init(void)
   
2. {
   
3.   huart1.Instance = USART1;
   ) N% t. O. H* m" h' i/ q: D: C, U% o# `
4.   huart1.Init.BaudRate = 9600;
   
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   ) t  W" r" C* l& E. A' L
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   $ @3 z5 `, a/ I# `' W" i& R
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   ( o/ k1 n$ k4 N
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)
    : w& C1 o0 H5 D* }
14.   {
    8 k. q$ g1 L7 }- O- b6 V5 d
15.     Error_Handler();
    9 X1 ~9 O2 e" \: O
16.   }  
    
17.         
    0 L3 M/ v: V* M7 q) P. q
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    + M1 ]/ N: @+ x, m. X' c# |
19.   {
    
20.     Error_Handler();
    
21.   }
    
22.         
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    9 d- D) z( M% @) p1 w  O
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    5 t. c" r/ O! G! w5 c0 t  U+ C
26.   {
    
27.     Error_Handler();
    - Q0 i( e9 ?4 r/ \8 X! M- G3 t
28.   }
    
29.         
    
30. }

复制代码

5 z: J5 r) `" q6 g% s ④ 接收空闲中断

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   ; S# Q5 C: x7 U; N) T9 M8 J; Y/ @
2. {
   " n- s" g# Q; W
3.     HAL_UART_DMAStop(&huart1);
   
4. 
   
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   / L: b- _9 N/ k; ~: J
6.         
   
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   
8.     data_length = 0;
   
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   ( |! O5 t6 r. ]" _
10. }
    
11. 
    3 F. n' o4 o0 C- C; {
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
13. {
    8 o7 Z! R* C+ P+ x
14.     if(USART1 == huart1.Instance)
    8 l6 D# M  F; A! [) b8 _( C3 u" J* k
15.     {
    
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
17.         {
    
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    2 k* G6 B/ n. N- ?  T6 H% i6 P4 ^
19.             USAR_UART_IDLECallback(huart);
    2 W) r- i+ j8 I
20.         }
    
21.     }
    
22. }
    
23. 
    ) j" z' c+ c/ g. M; G
24. /**
    - N' O3 T8 J8 f+ f
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    ' b- a/ c/ d' p" j: M* h" n3 w
26.   */
    
27. void USART1_IRQHandler(void)
    . f1 B) V8 H( x" ]# Q' n- r; Y
28. {
    $ W: W" X1 Y; _
29.   HAL_UART_IRQHandler(&huart1);
    
30.   USER_UART_IRQHandler(&huart1);
    
31. }

复制代码

0 `: P: r( o. m; O1 G. {, m⑤ 主函数调用：

1. #define TXBUFFERSIZE                    30
   % E, |' U3 U: _% G1 o
2. /* Size of Reception buffer */
   + ~$ E( m% o* q4 H9 i. V
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   " H+ q4 U1 d1 }% M
5. 
   
6. 
   
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   
8. 
   
9. /* Buffer used for reception */
   
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    
11. 
    
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    
13. FIFO_Type        fifo;
    
14. FIFO_Type        *pfifo;
    
15. 
    * u6 i4 Z. p& o( H  B5 H
16. int main(void)
    8 \$ S" O9 O6 W# g. Z- ^
17. {
    
18.   /*此处省略硬件初始化*/
    
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    
20.   {
    # m. c) W: t7 l
21.     Error_Handler();
    
22.   }
    2 D1 ~' O7 I5 E4 m( n2 f
23.         
    0 i+ c/ Y& p  C
24.   pfifo = &fifo;
    
25. 
    % U' N7 c( }/ ]: }" \  X$ @! X
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    
27. 
    # [/ }7 ?2 u% m6 ^2 i; D" f1 ^
28.   while (1)
    / [7 x/ G* C( k6 `/ n8 l- I+ M
29.   {
    
30.         /*一次接收的缓存，重新发送*/
    
31.                 if(!FIFO_IsEmpty(pfifo))
    8 Z- H5 }/ b# N$ ~
32.                 {
    , M" f/ m: Q9 t
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    7 N: i. [( S# T# B$ t/ j
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    7 ~1 L: Z& \/ V5 B/ @( H( `
37.                 }
    
38.   }
    4 q. f% P8 Y4 O1 x
39. }

复制代码

测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！
4 h; f  y. U. [6 S' A

6 K7 u8 N% ~+ O
' y. H$ d, m  J. e4 l  @问：关于 stm32 HardFault_Handler问题处理？
% l- a) Z- H; O) _1 x: E! h
ANS：
/ z/ S$ O  h$ a( N1 P
        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，

4 X6 D( [" Z0 V. D# ^ 最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！
; N1 w, I. c2 z1 u/ c

1. pfifo = &fifo;

复制代码

, d3 S7 x& P0 ]  @  r  S