一、STM32CubeMX开发
) J( X8 E' F. ^4 H2 Q. o5 h5 F$ V1.1 新建工程
9 `' Q0 |& l( I, z# efile -> new project
  D3 ?8 |& P0 P* I. c( ]
$ T" o" T6 A; e& X- U. v* q0 K选择芯片-> stm32 core内核         
' ^/ w' u% s/ O9 \) p& G
                   stm32 series 系列

                   stm32  line

& W* @2 O3 L7 N# e# z1 [; M                   stm32  package
6 }4 Z+ s' s1 d/ W
选择芯片根据自身需求去选择，目前该项目是stm32f0系列

& E. h: b+ v& B/ ~/ `' `1 h! a1 u/ ^# M                    stm32 core内核         M0
$ ?6 m! L) ]/ c; b
4 ]+ ~! A) @# q1 g                   stm32 series 系列      F0
" Y3 d1 D& V# Q2 r' O
: Z# }* }" h; m+ F% ~4 M                   stm32  line                 F0X1
0 P7 F) p" ]% d# K1 f. P
/ @) i6 d) H1 S0 D8 _! A  x                   stm32  package         TSSOP 20

, T4 g  P: q; p6 p5 O: Q5 U' o4 z* Q0 T 1.2 配置 USART1
配置 USART1 的模式为 Asynchronous，即异步串口模式
% g* @3 a- @0 ?: b+ s

  d( W' r' ^" H2 o6 L
1.3 配置串口参数
% y: Z7 t0 L4 T6 X* Q- T- L4 c 根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1

8 P$ J$ L0 f4 P

1.4 设置DMA
$ `/ I. }5 E5 [& A( X; i

/ J: |+ l3 s3 X0 d& A 1.5 添加串口中断
. g  Y  i2 r5 u
4 Y& Q" p! W' q4 M. l

1.6 生成源代码。
/ R: j& A( j1 q  i: n在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。
- v9 t. J$ w$ Y2 s( c
, t( U6 c$ {9 Y& K/ y+ c. V2 C6 c

& |9 ]1 F+ Z$ R4 L2 a; Y  x0 V9 _生成代码完成后可选择打开工程。

. {/ T1 j9 B5 t' I: `' B/ [  ^

+ N$ P/ R' ~( l+ }" r! l* o! P
5 ~, }  A+ ]9 N3 j: Q二、代码部分
2.1  接收中断处理
$ L0 a, ^/ F, R( }& H  x2.1.1 接收固定长度：（舍弃）
/ m! b8 ?/ x& {' A0 L只有接收缓存到固定长度才会触发中断
串口接收回调函数

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   ! b) o* I3 n: w& t  I7 _. J
2. /* Size of Reception buffer */
   2 n6 n  i8 i6 C4 E- p
3. #define RXBUFFERSIZE                    10
   
4. 
   ! O/ N6 r2 c+ v1 b. X/ H* a3 k
5. 
   
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   4 R5 E% ~7 u8 T! F5 Q
7. {
   
8.   /* Set transmission flag: trasfer complete*/
   - M4 N; s" t, C8 K( T
9.   UartrxReady = SET;
   
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    4 M. e1 K3 K6 J1 q' w0 e" n# k
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    / |3 X, M# d$ T# G* Y
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    , s( Y& K0 ]% o$ Z7 B4 y
13. 
    0 E% ^7 `1 o: I( Z% K- |) J
14. }
    # g7 A8 K- f, M
15. 
    % G) d. ?$ ]4 }6 l! ?3 M- A
16. void USART1_IRQHandler(void)
    
17. {
    
18.   HAL_UART_IRQHandler(&huart1);
    
19. }
    0 ]- m8 t, ]' e
20. 
    6 k8 A4 D& T9 _/ Q+ V5 A1 s1 G
21. 
    
22. static void MX_USART1_UART_Init(void)
    
23. {
      b, V- M) _* [1 O
24. 
    ( _7 M3 v* ]2 @" V/ f+ r
25.   huart1.Instance = USART1;
      z, Y& j' p0 h  c2 T
26.   huart1.Init.BaudRate = 9600;
    5 M9 ^" G# F( f  c- d3 V
27.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    * x" R. u6 ^/ ^& G9 w% d
28.   huart1.Init.StopBits = UART_STOPBITS_1;
    
29.   huart1.Init.Parity = UART_PARITY_NONE;
    9 ^9 W, _) R$ u" l  D, u& C% s
30.   huart1.Init.Mode = UART_MODE_TX_RX;
    9 Q5 J2 K7 c* J5 K
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    " e+ f# t6 H& {: D
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
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)
    
36.   {
    
37.     Error_Handler();
    $ p: D' ?( Q+ g  W3 m
38.   }  
    
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    * F+ G+ k9 W' M$ Q& i
41.   {
    
42.     Error_Handler();
    
43.   }
    
44.         
    : V5 o8 [, \5 n$ t+ d1 }0 ^
45.         UartrxReady=RESET;
    ' p4 G; A3 Z) q8 M3 ]  K2 }
46.   /* USER CODE BEGIN USART1_Init 2 */
    
47.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
48.   {
    5 ^* l3 S3 z# x6 A8 \) x( S3 F
49.     Error_Handler();
    / ?- v, b* N/ Z) z
50.   }
    ; @7 c' }# E  C8 _) Y( V
51.         
    $ q: b  O" K6 v3 W% d$ P5 [9 _0 n
52.   /* USER CODE END USART1_Init 2 */
    
53. }

复制代码

从串口调试助手可以看只有接收的长度 RXBUFFERSIZE为10时，才触发接收回调函数。
) x, b! u' ~/ f
, y1 {8 D3 |* P  F

/ j! f' j2 P4 r7 T; \7 V
5 M9 p  Z0 P# o3 N( U2.1.2 编写空闲中断函数接收不定长
# T( J( z( N; W# JUSART1初始化：

1. static void MX_USART1_UART_Init(void)
   
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;
   
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
     Y7 @& s$ p. N2 A/ `: n0 L- f7 Q, a* ~- j
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    % \! ]( X, V( _4 p2 j9 S7 K  a% }
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    ' Y2 M7 o- N, l) Q% ^, W# Z
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    7 S2 [. B" u, O: J' l/ K
14.   {
    
15.     Error_Handler();
    3 ?7 K. C" ?( g% ?+ T
16.   }  
    
17.         
    ) V2 m2 {# u" v
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    0 f6 f  k* J+ \5 a- u4 F1 B" |
20.     Error_Handler();
    
21.   }
    * W) G2 K4 ^- }
22. 
    
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)
    
26.   {
    0 ?; d4 D5 ]/ |  K* P, u" E- I( G! l
27.     Error_Handler();
    
28.   }
    
29.         
    
30. }

复制代码

+ a; Q* z% ]3 A1 q空闲中断函数：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    30
   ! ~/ O) A6 b1 C+ C% z  s' j  z4 I
4. 
   6 ]# T' @' B, t& V1 J5 Y; c
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
6. {
   
7.     HAL_UART_DMAStop(&huart1);
   . E2 p4 |  \, K: K3 n
8. 
   ; g# p7 |5 ~! Q% J* p. ~
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   * v6 Q7 j* h# U2 E. J4 Y; X! I
10. 
    
11. 
    
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    
13. 
    $ J3 I2 ~9 C/ \0 J, x) i
14.     memset(aRxBuffer,0x00,data_length);
    4 v" k- y! U& ?$ w  j  Z) Q
15.     data_length = 0;
    9 B$ k" E  T9 g# E7 t$ T
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    : @; u; h4 d* _1 i, _2 e  ~
17. }
    
18. 
    ; Q$ V, U( w& w" @! I
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
20. {
    
21.     if(USART1 == huart1.Instance)
    - f" t3 v3 f, _2 X5 s3 f* c
22.     {
    7 f3 e5 G  K, W' O. _! r
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    ; J; p. D' Y; i
24.         {
    & B, s4 T) n) z" O: J, T
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
26.             USAR_UART_IDLECallback(huart);
    ! w: y: N- {3 A* W$ R0 A
27.         }
    
28.     }
    # z8 w# C9 X; ?  V1 T& J7 ]
29. }
    
30. 
    / L) }7 R. @; k* a( x6 [) K5 z" c
31. /**
    
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    9 X, n3 Z- a' D- h$ ^, h: M2 y0 K" H
33.   */
    
34. void USART1_IRQHandler(void)
    5 a7 {, T1 J) @* V, r
35. {
    
36.     HAL_UART_IRQHandler(&huart1);
    
37.     USER_UART_IRQHandler(&huart1);
    7 c1 b; r' i9 X) e/ U
38. }

复制代码

可实现不定长的接收！

  T6 o1 k% X, W0 e* v

注意：
在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。

三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
使用原因：
/ [0 F4 k6 q* `
7 v5 h" ~  E1 u/ I1 `1 R8 ~        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。
2 F5 }* v' P) R
        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖
9 A4 a# W) B4 C; `4 |* _
① fifo头文件：

1. #ifndef        __FIFO_H_
   
2. #define        __FIFO_H_
   ! P3 C. n7 E+ Z" E
3. 
   / x) j2 S0 g+ [( E( m9 x8 X
4. #pragma pack(4)
   7 E% ]1 u6 n" U" i" K( v4 t
5. typedef struct FIFO_Type_STRU
   ) {+ e8 y0 f; \" t& X
6. {
   # w9 v6 x, P  S+ c5 T( j
7.         unsigned int                        Depth;                        // Fifo深度
   
8.         volatile unsigned int        Head;                        // Head为起始元素
   4 L+ w( A2 E3 q" N+ f
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    
12.         void                                        *Buff;                        // 缓存区
    
13. }FIFO_Type;
    * V5 z, K) I1 n* ~- h8 Q
14. #pragma pack()
    , h/ z* E( I: M
15. 
    
16. /********************************************************************//**
    9 a" r- D: W1 a1 e- m
17. * @brief       FIFO初始化
    
18. * @param[in]   pFIFO: FIFO指针
    
19. * @param[in]        pBuff: FIFO中缓存
    
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    / n" j) Z' Q) [5 b. x" N
23. *********************************************************************/
    
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    % R0 U2 A" O/ Q; a0 L  Q
25. 
    
26. /********************************************************************//**
    
27. * @brief       向FIFO添加一个元素
    % L9 h9 [. W1 X( Y5 f1 T9 c
28. * @param[in]   pFIFO: FIFO指针
    
29. * @param[in]        pValue: 要添加的元素
    
30. * @return      1-TRUE or 0-FALSE
    
31. *********************************************************************/
    
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    
33. 
    ) C, D3 C* {* J; |) `8 d( Q
34. /********************************************************************//**
    
35. * @brief       向FIFO添加多个元素
    7 I2 d3 b% x- b, h# h. Y
36. * @param[in]   pFIFO: FIFO指针
    1 ?9 }' y; S. R2 i2 w2 _
37. * @param[in]        pValues: 要添加的元素指针
      R6 z3 E; ?! m- V1 E2 N' W7 {
38. * @param[in]        bytesToAdd: 要添加元素的长度
    6 y( n7 ]3 N0 d7 Q: S: ~- \
39. * @return      实际添加的元素个数
    
40. *********************************************************************/
    
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    
42. 
    
43. /********************************************************************//**
    / N2 f% |! x0 B) a
44. * @brief       从FIFO读取一个元素
    ' I5 Y% s/ m+ _: U9 F
45. * @param[in]   pFIFO: FIFO指针
      A/ h$ X! |. b- c$ u7 {0 u$ o
46. * @param[in]        pValue: 存放要读取的元素指针
    
47. * @return      1-TRUE or 0-FALSE
    5 Q% ^" S% ~0 @& Y% @& V$ a
48. *********************************************************************/
    , b" N3 o; B1 z$ W, W0 X. a; J
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    
50. 
    
51. /********************************************************************//**
    
52. * @brief       从FIFO读取多个元素
    
53. * @param[in]   pFIFO: FIFO指针
    7 Z! v/ L7 E% T+ ^+ D
54. * @param[out]        pValues: 存放要读取的元素指针
    
55. * @param[in]        bytesToRead: 要读取的元素长度
    $ o9 q1 O* A  a# X9 S4 U5 O
56. * @return      实际读取的元素个数
    8 q; {% V* n$ O
57. *********************************************************************/
    0 ?! p* P% O4 j
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    
59. 
    1 n1 g) V8 ^! j$ j4 U) n* U
60. 
    
61. /********************************************************************//**
    * X) G6 n$ ]# z# M" L1 R' z) Y! U
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    7 e/ e2 o' g& O  o6 f- D
64. * @return      None
    
65. *********************************************************************/
    
66. void FIFO_Clear(FIFO_Type *pFIFO);
    ) Q+ q* `: t  y; c- u9 K
67. 
    ' a% _5 s) \! ]# U8 g
68. 
    
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    # t; z! A6 w# k4 N5 V/ P
70. 
    
71. #endif

复制代码

② fifo.c程序主体
' n: {/ Y: i, t9 j
2 p  E, ?8 n# u; c$ b, B

1. #include <string.h>
   
2. #include "fifo.h"
   ; t3 I2 K$ C# z* T- A( v  I' F; N
3. 
   
4. 
   4 c+ @1 L/ z$ h" ?, w
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   
7. * @param[in]   pFIFO: FIFO指针
   6 z/ ~# d# D3 D, u
8. * @param[in]        pBuff: FIFO中缓存
   
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   
10. * @param[in]        depth: FIFO深度
    1 `: d" }3 r! g/ O1 n
11. * @return      None
    . ?4 v4 K# r& S2 d6 N5 _6 A' L
12. *********************************************************************/
    
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    
14. {
    : X: A5 ]4 z4 s) B. s
15.         pFIFO->Buff = pBuff;
    
16.         pFIFO->ElementBytes = elementBytes;
    : M: j% Q9 Z8 Q- v5 [
17.         pFIFO->Depth = depth;
      @; J9 d- v( R7 l' i) n+ ~
18.         pFIFO->Head = 0;
    9 }) @9 y4 o8 b. w9 w$ A$ P
19.         pFIFO->Tail = 0;
    
20.         pFIFO->Counter = 0;
    
21. }
    0 K* _1 E2 T! M% z. a$ n
22. 
    " y3 u8 A! j& Y9 f& a
23. /********************************************************************//**
    
24. * @brief       判断FIFO是否为空
    
25. * @param[in]   pFIFO: FIFO指针
    
26. * @return      1-TRUE or 0-FALSE
    
27. *********************************************************************/
    4 G" N/ m8 T; p' o% @6 k1 Q6 E
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    
29. {
    8 p7 l2 _( K( x+ i. b8 N: Z9 z
30.         return (pFIFO->Counter == 0);
    
31. }
    : y& |3 Z6 z' s! H# w9 d4 N
32. 
    
33. /********************************************************************//**
    
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    1 \; ^* }& B( ~* _* r
36. * @return      TRUE or FALSE
    " s) d9 L& U" E' I" }
37. *********************************************************************/
    . S$ p+ A$ o) |& D  \* l
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    
39. {
    - G3 t2 x4 E7 [& I# j4 K: M& e
40.         return (pFIFO->Counter == pFIFO->Depth);
    9 s+ f9 g3 S0 C! ?9 Q2 M
41. }
    ! M8 l+ H% M8 E7 p+ D" |: R4 @
42. 
    ! W7 i7 M( [2 e- C3 g
43. /********************************************************************//**
    7 D( r# J+ K' p, q" K' R
44. * @brief       向FIFO添加一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 要添加的元素
    
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    & D. R$ ?8 |( K9 I
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    5 C9 z! d! k: o4 }1 c4 B
50. {
    - X) }0 V& `- J3 b! v3 n
51.         unsigned char *p;
    
52. 
    / y. t* Z4 p% A; C4 e
53.         if (FIFO_IsFull(pFIFO))
    
54.         {
    * `4 f1 g2 \& ]" m& [& E9 a# H( x8 ]# h
55.                 return 0;
    5 J/ }; s$ I: w  ?2 R% k+ z
56.         }
    
57. 
    % u# |; x; m3 `
58.         p = (unsigned char *)pFIFO->Buff;
    
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
    
60.         
    
61.         pFIFO->Tail ++;
    7 S0 W$ U  I0 @% ]5 ~  q
62.         if (pFIFO->Tail >= pFIFO->Depth)
    3 G: _6 R$ F# S9 L2 s: E- I+ v. ~
63.         {
    
64.                 pFIFO->Tail = 0;
    & H4 D+ F! p+ z. ]7 W5 J4 }
65.         }
    6 @! F7 _' y; E: D- o% l4 {- i
66.         pFIFO->Counter ++;
    ' F% K- E7 r- T4 J
67.         return 1;
    
68. }
    ( l" \- \5 v5 Q7 o0 S- u
69. 
    
70. /********************************************************************//**
    
71. * @brief       向FIFO添加多个元素
    
72. * @param[in]   pFIFO: FIFO指针
    / z3 z. ?4 I# }8 W& y) [
73. * @param[in]        pValues: 要添加的元素指针
    ) [( _: x9 e) p& x2 f" N
74. * @param[in]        bytesToAdd: 要添加元素的长度
    
75. * @return      实际添加的元素个数
    * k: r+ s" c7 z) E3 H3 y
76. *********************************************************************/
    
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    $ h- `, h8 |/ t: r& W, V/ [& b
78. {
    ; I' m9 ~9 d0 `; R2 f9 s" q
79.         unsigned char *p;
    * f  z  M# Y3 J. _; M
80.         unsigned int cnt = 0;
    
81. 
    
82.         p = (unsigned char *)pValues;
    
83.         while(bytesToAdd --)
    4 k0 E/ c- h$ E$ p% r! L  V% r: c- Q5 v
84.         {
    
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    
87.                         p += pFIFO->ElementBytes;
    
88.                         cnt++;
    
89.                 }
    
90.                 else
    
91.                 {
    $ J! l7 T1 s+ k: n
92.                         break;
    
93.                 }
    
94.         }
    
95. 
    & h4 V- N/ F0 h& R0 J7 L( p
96.         return cnt;
    & m; \" P+ p, |( ?% D: i
97. }
    * @9 D: `9 Z  n( O, D4 @
98. 
    
99. /********************************************************************//**
    2 E" ?- H3 Z* g" m
100. * @brief       从FIFO读取一个元素
     
101. * @param[in]   pFIFO: FIFO指针
     
102. * @param[in]        pValue: 存放要读取的元素指针
     
103. * @return      1-TRUE or 0-FALSE
     ! ]1 n0 ?4 l# F. ~# |) g; t# {$ L
104. *********************************************************************/
     3 w" X- c( s  R, c
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     
106. {
     8 T. W: L" q+ h3 E
107.         unsigned char *p;
     3 ?5 {$ b1 Y2 Q+ B
108.         if (FIFO_IsEmpty(pFIFO))
     ' M2 O3 e* W# C& i, N9 ]8 N% }
109.         {
     9 y3 M& V4 g1 ]
110.                 return 0;
     
111.         }
     
112. 
     - l% U" I- y5 [* y% H
113.         p = (unsigned char *)pFIFO->Buff;
     
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     
115. 
     & s9 X$ {8 v' _( K7 O6 y  j2 Q
116.         pFIFO->Head ++;
     # N- Z2 W, G  L
117.         if (pFIFO->Head >= pFIFO->Depth)
     5 a  r5 z3 j/ Y0 J" P
118.         {
     
119.                 pFIFO->Head = 0;
     , c3 j  p- ^" Y) B9 C4 J
120.         }
     
121.         pFIFO->Counter --;
     3 N  k& y" |* k6 H6 b; ]4 o* H/ X
122. 
     ; {% y7 v* r1 B6 Q+ n
123.         return 1;
     ! @  Y" w8 ]4 n0 R/ o2 T2 W& ^
124. }
       F8 @6 i) L4 Z) f/ i8 z6 L
125. 
     ; R( ^; l3 P! N1 ?7 k" O
126. /********************************************************************//**
     * l( |7 H( ]" C9 y6 e
127. * @brief       从FIFO读取多个元素
     
128. * @param[in]   pFIFO: FIFO指针
     2 C0 O3 p, p  B: R. a
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     
131. * @return      实际读取的元素个数
     
132. *********************************************************************/
     7 t" e; S4 o7 @! @
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     # m& f4 d! ~6 b' Z$ _0 ]
135.         unsigned int cnt = 0;
     
136.         unsigned char *p;
     
137. 
     3 i8 i5 U6 q! D" o
138.         p = pValues;
     
139.         while(bytesToRead--)
     : Y8 c: s# k% C* f
140.         {
     
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
     , S4 t6 |4 J  u, C/ q6 _
143.                         p += pFIFO->ElementBytes;
     " H* M/ h' j( o  m6 j/ B
144.                         cnt++;
     
145.                 }
     * e, @9 l6 n7 ^/ u# J3 A' }! ?
146.                 else
     3 m$ g) A' c% I8 N! T8 V
147.                 {
     " B( o  [$ }+ d$ N( a
148.                         break;
     ; m+ R5 H  A& {1 n& i# f
149.                 }
     
150.         }
     ; Z2 ~2 a7 `" |9 l7 \9 Z7 {
151. 
     
152.         return cnt;
     % ]- z& |2 C3 ^
153. }
     
154. 
     
155. /********************************************************************//**
     - x% i8 |0 N0 I2 D
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     5 D2 P5 E7 F$ N- Y4 o
159. *********************************************************************/
     
160. void FIFO_Clear(FIFO_Type *pFIFO)
     9 j5 n( S- k3 y) G$ \
161. {
     * H6 F+ I7 |, k4 ?3 c1 c2 ~
162.         pFIFO->Counter = 0;
     - U/ v& g1 D( P  \. E% G
163.         pFIFO->Head = 0;
     0 Z& y* ]% b, m2 O
164.         pFIFO->Tail = 0;
     ' ^6 x. Z, ?) k! `2 m2 f! {) L
165. }

复制代码

③ 串口初始化

1. static void MX_USART1_UART_Init(void)
   ) C0 M! I/ V# p3 o0 f5 A2 q+ f, K! D. d
2. {
   9 O7 `$ J* `  v$ K/ p) r" v
3.   huart1.Instance = USART1;
   
4.   huart1.Init.BaudRate = 9600;
   ! s/ x* x/ {  m, R  V, u% i" }* m+ u* x
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   ' U6 ~. k& U2 I# X$ z0 q
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   + ~$ m1 h% s5 T  N$ d0 E* d( \8 ?
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   3 T& N% f( f$ y8 g) q' ~$ Q" C
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    3 T& n2 D4 e; Y+ [: K
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    $ Y5 B) \! ^( a( R5 a, t6 p, S; ]
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
      P' X7 a* C! `9 ^7 Y
14.   {
    
15.     Error_Handler();
    
16.   }  
    # ~+ d6 _3 O% |, R" j
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    9 ^$ F* j( _7 R+ n) u
19.   {
    
20.     Error_Handler();
    
21.   }
    
22.         
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    - k; p/ Z, V. Q1 a
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    - J" b: n: k5 S- F
27.     Error_Handler();
    1 _# c4 i. @$ r
28.   }
    4 n0 V' C; k/ k. _6 g3 W) I
29.         
    
30. }

复制代码

④ 接收空闲中断

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
2. {
   
3.     HAL_UART_DMAStop(&huart1);
   
4. 
   
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   * a% L1 F# @0 J3 e) Q7 H
6.         
   
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   7 q9 x, W: l' M' z% A. d
8.     data_length = 0;
   $ L9 E* `; o8 S- p8 f
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   
10. }
    8 h8 s6 b  Z9 p+ r
11. 
    
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    9 o7 x1 n' j# V8 B
13. {
    
14.     if(USART1 == huart1.Instance)
    + i: L2 P6 r+ \" g" L% s. Y% |" ?
15.     {
    : f$ U" Y5 S2 q
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
17.         {
    & H/ {) z6 k$ J  E! q
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    ; u2 E% i0 h$ m8 m" P
19.             USAR_UART_IDLECallback(huart);
    
20.         }
    7 e0 k4 i( i. I0 k1 t% Q4 V
21.     }
    ( I- _4 `# n: u
22. }
    
23. 
    
24. /**
    1 Q) d5 a9 @) o
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    # A9 [1 K9 [/ k. n! J9 p# x
26.   */
    
27. void USART1_IRQHandler(void)
    + x- k1 G6 T9 F6 M0 E
28. {
    : x* f) c' A1 @' W8 B
29.   HAL_UART_IRQHandler(&huart1);
    1 u8 P- U7 A" E
30.   USER_UART_IRQHandler(&huart1);
    & z) x% u* n* H5 p: ?
31. }

复制代码

3 k  d, F7 m% ]* T5 v⑤ 主函数调用：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   , Y) I0 e( f0 \' r
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   2 j6 ^8 Z5 T& P
5. 
   
6. 
   
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   0 _$ `+ z7 p! Y  r% z
8. 
   
9. /* Buffer used for reception */
   ; O$ H+ A, d+ j9 P0 x* V
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    8 x2 J  A! ^) V" |
11. 
    : J1 }  f. w% D; K, H7 o
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    * V, S! [+ \2 L# \& B! ?# R) r
13. FIFO_Type        fifo;
    
14. FIFO_Type        *pfifo;
    , G1 x- I% b! `
15. 
    ) V* ]5 g/ k5 q+ u4 r% e# u) d" @
16. int main(void)
    
17. {
    
18.   /*此处省略硬件初始化*/
    6 U: z8 c  S  G. ~
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
      v) U1 e0 D' {# a" ~, V# l
20.   {
    
21.     Error_Handler();
    - b  b8 U1 B4 U' a
22.   }
    
23.         
    
24.   pfifo = &fifo;
    & e1 X, x3 t$ G+ H& ]+ F
25. 
    " X- V3 _4 \6 p
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    
27. 
    
28.   while (1)
    
29.   {
    3 ?7 z( u! `0 @8 [- @, n
30.         /*一次接收的缓存，重新发送*/
    
31.                 if(!FIFO_IsEmpty(pfifo))
    
32.                 {
    
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    2 K. ?9 s2 A4 B* Y) Y, G5 F
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    , z0 _# v# M& [' w( G
37.                 }
    
38.   }
    : Y5 e: [0 ?4 o  x
39. }

复制代码

  L+ p3 L* J3 d% `) E% l测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！
  w) \/ e( U7 X9 c

问：关于 stm32 HardFault_Handler问题处理？

ANS：

0 ~- X0 M" |- l: N        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，
6 @7 W+ a+ T! q' i" a7 v1 K/ r
8 O2 a# C) b6 [; a( M% d. Y

: Q  v! U$ y; ?; h( R1 g6 h

) ?( j7 E: ~5 x5 J: n
& `4 {# M: U6 e 最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！

1. pfifo = &fifo;

复制代码

+ j$ b8 X8 ?1 G  s- a' y


3 h( E5 z. M) c' u( G