一、STM32CubeMX开发
1.1 新建工程
, H- U/ G2 h& z, B1 Ffile -> new project

' g4 l' k5 u* k6 d" h4 m选择芯片-> stm32 core内核         

3 m, ~; `$ N( I/ @                   stm32 series 系列
$ y2 p2 _! ~4 S! P1 V  V  @7 T
                   stm32  line

  e5 E, L0 _0 g6 H                   stm32  package

选择芯片根据自身需求去选择，目前该项目是stm32f0系列
0 g. {/ B: V8 p" t% i& h9 j
: ~, ~# C. G- ~. e' B( K                    stm32 core内核         M0
* [+ d9 ?: o! C) |. I0 W; ?2 w
                   stm32 series 系列      F0
7 q' l& ]# C! w% b1 K
& y, X' ~6 Z0 Z: {# o1 c7 ?* t                   stm32  line                 F0X1

& b4 e# T) u) @9 e8 S$ ^                   stm32  package         TSSOP 20
) o; k* s& Z) k+ O5 V. D5 X
1.2 配置 USART1
) z+ N) C- S7 e3 }" ?$ W/ i$ f配置 USART1 的模式为 Asynchronous，即异步串口模式

' R. E" j, `$ d7 Q% }

1.3 配置串口参数
/ a6 B4 I$ [9 `6 z 根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1
& u5 h4 P( {( H4 Z* \% F2 U
5 A7 D: n" j. p8 `3 Z2 F

0 c9 c! d& a4 r! d4 G$ U  ~" T 1.4 设置DMA
- m' m+ k/ w- o( |( E& E2 m: ^

, @* l' D5 w5 L1 ?& i  z4 `
! |; N5 j- u7 \% z2 \ 1.5 添加串口中断
3 i2 o# f# V2 p
) q8 ^9 \4 b$ r! o& b4 _. l4 M

3 G+ N1 P5 |8 @  m" v% n
5 L# ]6 g! T4 j7 v- W: a  t 1.6 生成源代码。
& o. u$ K% |# r1 i在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。

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

, H" ]: z3 H  |1 ?; `7 e1 f
" |% V$ T$ r5 p二、代码部分
2.1  接收中断处理
2.1.1 接收固定长度：（舍弃）
* ?, f( e( A' G, h3 L$ q% M只有接收缓存到固定长度才会触发中断
串口接收回调函数
4 n: t9 |* r" Q/ A
( @4 u/ @' H2 c/ T4 W3 ^

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    10
   ) N1 S+ q; F# A% O: Z/ p- f
4. 
   7 N' q( P3 r/ o5 A. p" k% R
5. 
   ! `% s! c) p3 {3 j- X
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   
7. {
   
8.   /* Set transmission flag: trasfer complete*/
   
9.   UartrxReady = SET;
   
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    + [" Y% }1 ~  R. E+ ?1 d
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    1 k/ O; `8 B3 ~  V# E3 N
13. 
    
14. }
    4 H- ~4 P- U* R2 T$ W+ h' M
15. 
    
16. void USART1_IRQHandler(void)
    
17. {
    
18.   HAL_UART_IRQHandler(&huart1);
    9 U; I% q, u) I
19. }
    
20. 
    6 O5 \- q: X) W( O
21. 
    1 x0 W9 g& A; A- r
22. static void MX_USART1_UART_Init(void)
    & _% ]+ c" Y6 b- ^/ U
23. {
    & L; U" A  x4 z! \1 @' W/ k9 B
24. 
    7 I7 z; w8 z' z* |
25.   huart1.Instance = USART1;
    
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;
    
30.   huart1.Init.Mode = UART_MODE_TX_RX;
    
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    , e8 @$ R1 h$ R# w
33.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    ' Z" \; t6 s3 C& ]! o+ N+ M" q7 ~/ r
34.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
35.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    4 ?! b# O7 x7 r
36.   {
    " j3 `& `, z8 L  c. d
37.     Error_Handler();
    & P6 H9 v8 ?* }8 k: b/ z
38.   }  
    ( u% A1 T; x3 T. t
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    $ q! }2 z, m2 A6 ]; {! y  _! y
41.   {
    9 m4 R* v7 H8 p' l: Z0 y& E
42.     Error_Handler();
    
43.   }
    
44.         
    " R5 e# P9 [! X$ q3 Y
45.         UartrxReady=RESET;
    7 Q; }( N& g8 x' n+ Q$ I
46.   /* USER CODE BEGIN USART1_Init 2 */
    3 b' _( o0 ]$ L5 h
47.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    . D1 H2 g7 Y" s/ l( d
48.   {
    
49.     Error_Handler();
    : W8 H9 U  L% _8 A. S9 c
50.   }
    
51.         
    
52.   /* USER CODE END USART1_Init 2 */
    
53. }

复制代码

从串口调试助手可以看只有接收的长度 RXBUFFERSIZE为10时，才触发接收回调函数。
" j+ A& `. U1 B' q* B$ O: q

% O9 V* b6 W+ C2 H3 Q0 v4 ]
7 m: C: a+ K( S+ [8 l4 c2.1.2 编写空闲中断函数接收不定长
USART1初始化：

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;
   ' {" f! q" }4 u0 X1 C4 v) ?- I
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   % A2 u3 R, G8 ?# G6 A* U. N
7.   huart1.Init.Parity = UART_PARITY_NONE;
   & K: @3 ]$ S+ f
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   # m' v9 ~9 |6 ^6 N% T3 y. V
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   - S$ s1 T# M, s8 {, k/ M
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    ; ~, J4 e7 ?, I
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    ) ~0 I: @! B' {$ p* j) G5 w5 O
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    
14.   {
    
15.     Error_Handler();
    
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    ) D7 {- w& T; G0 X4 X1 P- @. G+ @
19.   {
      h- L$ D( X$ A9 T6 S' Q  l
20.     Error_Handler();
    
21.   }
    " |3 o; o% o0 s3 ~1 V2 s
22. 
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    ; I/ H. @6 |) V! a  E1 @4 K
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    
27.     Error_Handler();
    
28.   }
    / P+ n3 m" ]+ |$ E9 l5 {! [
29.         
    
30. }

复制代码

* C6 ?: n/ i7 x% M空闲中断函数：
1 `) x$ |+ K: B9 Q1 ]2 t3 Q

1. #define TXBUFFERSIZE                    30
   2 T6 `$ j) m) {+ o; w
2. /* Size of Reception buffer */
   " x3 Z3 o+ N5 t" j) a9 x
3. #define RXBUFFERSIZE                    30
   
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   7 n1 B6 `* H! R/ S! W9 I8 k& R
6. {
   
7.     HAL_UART_DMAStop(&huart1);
   6 D# ]3 e6 _. e7 m+ ]2 Q* Y" b
8. 
   
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   
10. 
      r  n- V( q) A" g' h' g! d
11. 
    ( `- L, X* a8 t8 n
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    ( n1 Q0 G2 s; X' h
13. 
    . J! M7 _* s" L
14.     memset(aRxBuffer,0x00,data_length);
    : i7 `$ M5 r7 O* q; ]# M
15.     data_length = 0;
    
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    $ h$ \# h% ]- H" f" s/ E0 Y
17. }
    
18. 
    
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    ( p6 ]! e1 f; S$ Y3 |8 U$ y/ G8 S. ?
20. {
    ) y/ x5 B6 B! o  W* D! j; l
21.     if(USART1 == huart1.Instance)
    
22.     {
    
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
24.         {
    
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
26.             USAR_UART_IDLECallback(huart);
    . o* Z" S3 B) P6 O7 }$ g
27.         }
    ) [& z/ o4 S4 j/ x
28.     }
    / o- C( e: W# H/ e4 m
29. }
    ' a' m5 v! w- |' y6 o# S
30. 
    # c9 ~3 j( X9 }9 ]
31. /**
    
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
33.   */
    
34. void USART1_IRQHandler(void)
    
35. {
    
36.     HAL_UART_IRQHandler(&huart1);
    
37.     USER_UART_IRQHandler(&huart1);
      c* W  [5 K" w+ K
38. }

复制代码

可实现不定长的接收！

. q' a! u  _5 G5 f
注意：
: C2 C/ z" |# t3 n: X6 @. K在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。
, G! L  S3 h3 C
4 g- F1 b2 F- r+ a8 b# X4 J3 r 三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
2 t2 g) p3 m2 W使用原因：

4 H0 [) E7 X4 B  f! b" t1 q        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。

% [1 [  u: T4 ~! F+ q9 ?        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖

6 i: M/ U3 ^$ ?① fifo头文件：

1. #ifndef        __FIFO_H_
   
2. #define        __FIFO_H_
   ' c5 t1 m$ b/ u2 @
3. 
     B, J8 }1 X: K" ]6 M
4. #pragma pack(4)
   2 \* x2 A4 C1 J7 {. z7 S" p' z$ p
5. typedef struct FIFO_Type_STRU
   
6. {
   2 d+ i+ i* s8 m' i0 X) X/ f: z
7.         unsigned int                        Depth;                        // Fifo深度
   8 Q- S, _- L* O1 M" E
8.         volatile unsigned int        Head;                        // Head为起始元素
   ! y0 y& N2 ?+ O1 B
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    2 l( ]2 ]3 l. s- S. u+ q. x7 s5 X& U: H
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    
12.         void                                        *Buff;                        // 缓存区
    
13. }FIFO_Type;
    / x) L& E! v  U/ j7 Z
14. #pragma pack()
      c# U2 ?0 a! e5 c, x6 w# W3 a
15. 
    , Q8 a* q  l  D7 [! c0 ]' s
16. /********************************************************************//**
    / R& u  x, T, K/ {
17. * @brief       FIFO初始化
    
18. * @param[in]   pFIFO: FIFO指针
    
19. * @param[in]        pBuff: FIFO中缓存
    3 h  n# f4 F7 q/ A- p
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    : i7 X, p( j/ w4 F8 D
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    
23. *********************************************************************/
    1 m7 A9 u1 f5 ?1 S2 E& q
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    ; h% b0 N! e. {
25. 
    
26. /********************************************************************//**
    # }) a* e8 }" H& m9 ^9 q
27. * @brief       向FIFO添加一个元素
    
28. * @param[in]   pFIFO: FIFO指针
    / }8 S6 i$ }6 V. L$ U/ q0 t1 S3 J
29. * @param[in]        pValue: 要添加的元素
      N" J! }8 g7 W% O( P2 [9 _3 d% j- q
30. * @return      1-TRUE or 0-FALSE
    - C; L' E: p( F& Z" v/ m
31. *********************************************************************/
    
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    & O2 w: h) r( _/ @9 G0 D* n& X
33. 
    
34. /********************************************************************//**
    0 W! P* j0 ^# {9 o8 i; V5 v
35. * @brief       向FIFO添加多个元素
    
36. * @param[in]   pFIFO: FIFO指针
    % e" f5 T+ v5 ?4 `' b! j
37. * @param[in]        pValues: 要添加的元素指针
    + y) J4 s5 w# _5 T+ D) v- C2 t
38. * @param[in]        bytesToAdd: 要添加元素的长度
    * s( W" A' S* e9 W( H7 G6 c5 y) ^  L
39. * @return      实际添加的元素个数
    
40. *********************************************************************/
    4 F1 H+ r% d7 R! p5 p
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    
42. 
    0 a. }2 b5 u3 |
43. /********************************************************************//**
    
44. * @brief       从FIFO读取一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 存放要读取的元素指针
    ' B6 l4 C8 ~( T$ ?& Q! `$ v1 N  j
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    
50. 
    . h& `% Q0 l' Z  {
51. /********************************************************************//**
    
52. * @brief       从FIFO读取多个元素
    
53. * @param[in]   pFIFO: FIFO指针
    3 R% b# Q# d  e! L. d
54. * @param[out]        pValues: 存放要读取的元素指针
    
55. * @param[in]        bytesToRead: 要读取的元素长度
    
56. * @return      实际读取的元素个数
    
57. *********************************************************************/
    4 O( T. H) ^  I% g, D
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    ; b5 t, Q) j0 U
59. 
    
60. 
    
61. /********************************************************************//**
    2 U3 o2 z/ C4 [# a5 n. h( ]; Y8 N
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    0 e0 e; p! m6 K4 @% Z% ^
64. * @return      None
    
65. *********************************************************************/
    - x+ H; w" q7 K5 w4 H( |0 E" u
66. void FIFO_Clear(FIFO_Type *pFIFO);
    
67. 
    
68. 
    
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    
70. 
    
71. #endif

复制代码

+ f. q. e0 h7 I5 X# F' i# T② fifo.c程序主体

8 z' C6 |! X5 D: a. d2 q

1. #include <string.h>
   2 _& k/ I, J6 k* N& {5 D5 o0 a
2. #include "fifo.h"
   
3. 
   
4. 
   
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   : \; p0 W: c- Y" {, S! X
7. * @param[in]   pFIFO: FIFO指针
   
8. * @param[in]        pBuff: FIFO中缓存
   / K* l0 _! z) J' d3 Z. U* x2 n( k4 u
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   # K4 X1 k( f0 h
10. * @param[in]        depth: FIFO深度
    ) T5 |/ t7 ^  _% N
11. * @return      None
    
12. *********************************************************************/
    
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    , A' o# h2 Z" E0 O
14. {
    - `% ?4 N5 G2 L( ]8 A4 }2 X0 U
15.         pFIFO->Buff = pBuff;
    5 n+ {- y' k7 b9 s
16.         pFIFO->ElementBytes = elementBytes;
    % i6 S7 y7 K9 }# m' _# n8 [
17.         pFIFO->Depth = depth;
    : k- o% E" l4 u0 T8 w) s2 U
18.         pFIFO->Head = 0;
    
19.         pFIFO->Tail = 0;
    
20.         pFIFO->Counter = 0;
    - b2 T! |2 y$ f- v
21. }
    . ~) L2 h- e+ _8 @0 D( T" ~" `8 Y
22. 
    
23. /********************************************************************//**
    , a$ @% X( w0 _1 i- k3 G  Q
24. * @brief       判断FIFO是否为空
    : R) W, ^# X! p2 t$ e6 G! F
25. * @param[in]   pFIFO: FIFO指针
    - L5 r/ R+ M& ?, t
26. * @return      1-TRUE or 0-FALSE
    
27. *********************************************************************/
    
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    
29. {
    ) ]! |+ Y  C! p! O1 K& G3 U8 p
30.         return (pFIFO->Counter == 0);
    ; B6 g3 K1 S% E, B$ ^- r
31. }
    4 S. N# P0 g7 E( j
32. 
    9 C+ P2 `1 [( @3 u
33. /********************************************************************//**
    6 f' ^! v) |8 K5 {
34. * @brief       判断FIFO是否已满
    1 O  J& O1 ?' ?" z
35. * @param[in]   pFIFO: FIFO指针
    
36. * @return      TRUE or FALSE
    
37. *********************************************************************/
    
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    : ~3 b4 H/ B" E$ ~) G7 u
39. {
    $ }/ S( b. A% G2 r& L3 u0 D& v* z
40.         return (pFIFO->Counter == pFIFO->Depth);
    / C1 ]! T0 q! ^( I
41. }
    9 X. g$ N2 Y# i5 ~' X: C6 S
42. 
    9 w& b1 ^! n5 v7 t0 X! f" |# F
43. /********************************************************************//**
    * x7 P# g) _" w  C; S9 Q3 `, J/ ^8 W
44. * @brief       向FIFO添加一个元素
    ' I' H) m4 n& C* `0 G
45. * @param[in]   pFIFO: FIFO指针
    ( b3 ?7 p8 \. R
46. * @param[in]        pValue: 要添加的元素
    1 k7 j7 X, p7 T+ T8 b) K2 t9 J0 ^* `
47. * @return      1-TRUE or 0-FALSE
    ' x7 s- @) k+ t4 C9 O; R
48. *********************************************************************/
    / _) x2 g  w: u* P6 B
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    # I: W3 x8 b  D" k# m5 f
50. {
    2 ?! l7 k) V; P5 \' Y% J6 C9 p
51.         unsigned char *p;
      L6 n, T7 V& D! g; l- N& I( y( k
52. 
    5 [$ b/ O; X$ B$ q% y' |) C
53.         if (FIFO_IsFull(pFIFO))
    ; _; K$ X8 D# j$ m
54.         {
    # L4 P3 [  B9 Y( I
55.                 return 0;
    8 K; W( }$ l* Y2 k
56.         }
    3 R4 y' X) |5 s; n
57. 
    
58.         p = (unsigned char *)pFIFO->Buff;
    " H" X8 w# l% p5 X9 w3 Q, x
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
    - x2 \# C/ Q$ V7 M: G( }
60.         
    
61.         pFIFO->Tail ++;
    
62.         if (pFIFO->Tail >= pFIFO->Depth)
    : d8 F, J2 D* I8 U
63.         {
    & @; L& @0 H; C. G; Z& Y
64.                 pFIFO->Tail = 0;
    
65.         }
    * E% V0 Z' ^. W' w2 b" l4 l2 J
66.         pFIFO->Counter ++;
    
67.         return 1;
    + F) e$ Y$ E% L0 A$ P
68. }
    " ?% U6 w$ m. M( @" B0 H
69. 
    
70. /********************************************************************//**
    $ n0 l/ n0 l0 l7 x1 B
71. * @brief       向FIFO添加多个元素
    
72. * @param[in]   pFIFO: FIFO指针
    
73. * @param[in]        pValues: 要添加的元素指针
    
74. * @param[in]        bytesToAdd: 要添加元素的长度
    * S' W5 c; o' s! W
75. * @return      实际添加的元素个数
    / y% k6 e- u3 i- N4 k% g9 B0 @
76. *********************************************************************/
    , E+ |  r) i3 p6 W5 X0 _
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    ! ~" G- u' t: x1 u
78. {
    
79.         unsigned char *p;
    
80.         unsigned int cnt = 0;
    % i) V) [# G$ M6 z) e6 y3 |- n
81. 
    ( q3 P7 G9 R# n& r
82.         p = (unsigned char *)pValues;
    2 x( @- c3 b! B* b- p1 r: p9 E
83.         while(bytesToAdd --)
    
84.         {
    
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    2 n7 @9 R2 Y* \5 a
87.                         p += pFIFO->ElementBytes;
    
88.                         cnt++;
    
89.                 }
    + i5 c" I: W- _
90.                 else
    
91.                 {
    4 i/ K5 C" ^" k+ {( u! v& b
92.                         break;
    ! ]* C( l" _! u7 t- }# _
93.                 }
    
94.         }
    % ~! G" a  S( e2 S5 R0 b9 I$ h
95. 
    0 g% O! a4 U" e8 Y
96.         return cnt;
      d" D) \* N- F3 C0 ^4 G4 N: B
97. }
    
98. 
    6 L( X+ g0 _- G
99. /********************************************************************//**
    . E# m% d1 I+ z, c
100. * @brief       从FIFO读取一个元素
     
101. * @param[in]   pFIFO: FIFO指针
     9 s! O1 Y: |3 f" m
102. * @param[in]        pValue: 存放要读取的元素指针
     $ E  g0 S6 v. X' V
103. * @return      1-TRUE or 0-FALSE
     
104. *********************************************************************/
     
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     
106. {
     7 h' N# t1 `4 L  x- u( y
107.         unsigned char *p;
     
108.         if (FIFO_IsEmpty(pFIFO))
     7 W9 x/ @/ _; j9 {
109.         {
     7 s% ?9 S3 z% K% o; F
110.                 return 0;
     " S" {2 u3 ^: G2 |6 l( l
111.         }
     
112. 
     3 D: H& U7 O9 u+ T6 Z
113.         p = (unsigned char *)pFIFO->Buff;
     
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     
115. 
     
116.         pFIFO->Head ++;
     7 b6 O% c6 s% J5 l: d
117.         if (pFIFO->Head >= pFIFO->Depth)
     ) P. w) L/ s& ~' ~4 Y; ^; j1 \
118.         {
     
119.                 pFIFO->Head = 0;
     
120.         }
     
121.         pFIFO->Counter --;
     ( g& j6 c) v. G. S- I3 t( c
122. 
     
123.         return 1;
     : t0 C4 l) h! ?9 ?: x
124. }
     ) b' w: G; E, y$ y6 T# u+ n: N
125. 
     ' Z2 p+ i: T# o
126. /********************************************************************//**
     - x0 `, Y! h2 W% @
127. * @brief       从FIFO读取多个元素
     ) d( V9 A7 L/ l+ Q9 z
128. * @param[in]   pFIFO: FIFO指针
     & G0 W5 Y! k$ @" Q
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     * v. B, H$ W& d0 c; |$ X
131. * @return      实际读取的元素个数
     % t- u6 D5 G  U9 k' J
132. *********************************************************************/
     
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     0 o' K5 M& G, ^; K# u/ x& S* e
135.         unsigned int cnt = 0;
     
136.         unsigned char *p;
     ! n3 v! i: A4 I4 j6 q
137. 
     
138.         p = pValues;
     6 a1 S  @! S0 K$ D! |2 o
139.         while(bytesToRead--)
     " J0 p3 {# o- b; m# y
140.         {
     
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
     
143.                         p += pFIFO->ElementBytes;
     
144.                         cnt++;
     3 Q$ c; ^5 T3 X, Z7 R  |, t5 F
145.                 }
     ' n& c/ O, D2 c) D, G% d0 W+ [. w% P
146.                 else
     
147.                 {
     / r& E8 t, ]( S- ~8 N( D0 P
148.                         break;
     ' ]  P& q- F8 o. Q; t' `$ Q* K: r1 D
149.                 }
     % q* B: S5 C3 @, C5 j
150.         }
     % F  _8 W" t3 `8 A& ^, p  y! b
151. 
     
152.         return cnt;
     * D# g+ R. ?5 Z* F% N7 J7 K) c
153. }
     
154. 
     
155. /********************************************************************//**
     
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     % ~' ?# w3 n& t1 V; e+ E5 F
159. *********************************************************************/
     
160. void FIFO_Clear(FIFO_Type *pFIFO)
     - A+ s7 }, w4 O3 Y* M2 X$ H
161. {
     
162.         pFIFO->Counter = 0;
     
163.         pFIFO->Head = 0;
     4 |* K9 O6 o6 x2 b' p
164.         pFIFO->Tail = 0;
     
165. }

复制代码

/ b& t, P( f# T  W, @; J# U ③ 串口初始化
) \" [* o) N; A! b

1. static void MX_USART1_UART_Init(void)
   * w  \, ~+ O; D% g9 l6 Z/ T+ W
2. {
   
3.   huart1.Instance = USART1;
   ! k; x& v+ {0 p
4.   huart1.Init.BaudRate = 9600;
   ' d  C; V0 G# W2 Q* W  ]
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   7 ^$ s' s* {+ m# U  j
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   ' ^1 H6 y5 I3 S& I, b- w1 L* E& M
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   9 P" o' Z6 Y; |9 i; P9 Q. `" `0 Z
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   ) E) P; M7 \8 o
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    , d, D0 d% a( v  Y0 i. \
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    + ^8 j% }  W) _7 I8 F' r2 b8 i
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    % A6 \# L6 S+ a2 w
14.   {
    
15.     Error_Handler();
    5 J, D0 P, U8 N
16.   }  
    % @, J$ q6 h+ D' I9 y) S* U5 ^
17.         
    ' D7 L  N, V1 @7 p; s+ ?
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    
20.     Error_Handler();
    
21.   }
    
22.         
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    ) Y9 E! g$ `" w: {: j7 u
24.   /* USER CODE BEGIN USART1_Init 2 */
    3 Z; |" Z4 D0 L4 h! H+ `
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    
27.     Error_Handler();
    ( d0 K! t3 e0 r
28.   }
    " k; J0 {/ g! d$ Y# y; P$ \
29.         
    
30. }

复制代码

④ 接收空闲中断

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
2. {
   
3.     HAL_UART_DMAStop(&huart1);
   ' U) E* u7 r5 \! o& m0 @
4. 
   1 G* J1 \9 E( Q( b
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
     r' i. a- ]5 v( Y
6.         
   5 R9 d3 y+ M: \- w
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   
8.     data_length = 0;
   
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   3 b/ _3 e8 Y6 d0 y# q
10. }
    
11. 
    / n1 {9 R6 T/ B7 \9 G
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
13. {
    ( F/ f" X# }6 k, D2 E4 t
14.     if(USART1 == huart1.Instance)
    
15.     {
    9 D: C: a+ a4 f2 c' c
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
17.         {
    " U! z. J" ]' {( F/ K
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
19.             USAR_UART_IDLECallback(huart);
    * X7 i3 v7 U9 g  X) n3 T& j$ v
20.         }
    $ H1 L" B" P+ d0 a5 Q2 i7 ~9 k
21.     }
    
22. }
    
23. 
    & p4 G% S3 t4 p
24. /**
    
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
26.   */
    / t% Y) W, Y5 n* W
27. void USART1_IRQHandler(void)
    7 Y8 T+ o: ?3 @) c+ [2 f
28. {
    $ b7 p& B: \2 {/ K9 D
29.   HAL_UART_IRQHandler(&huart1);
    
30.   USER_UART_IRQHandler(&huart1);
    9 |' _) _' J5 k" N/ h: \. [3 B
31. }

复制代码

) N. Q5 h7 i; q( F⑤ 主函数调用：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   1 _* n1 U) L, L
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   ) f3 d' @* [. `# ~
5. 
   5 }& c7 M# s  N
6. 
   
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   
8. 
   & o/ R2 m) ~9 f- M1 h
9. /* Buffer used for reception */
   
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    
11. 
    7 ^, q+ v* h# S4 o: _# y
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    
13. FIFO_Type        fifo;
    
14. FIFO_Type        *pfifo;
    
15. 
    4 H* E; o5 k  W' r" y* {
16. int main(void)
    , w. D8 t& k: Q/ ?  }! |
17. {
    ) ~0 A- M2 {* M# M
18.   /*此处省略硬件初始化*/
    
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    $ e7 q" v8 F2 P5 k  o5 b
20.   {
    : a8 G6 t2 Y& ?1 d1 m/ T4 ^
21.     Error_Handler();
    5 V- T" N% }" ~" _5 Y1 l
22.   }
    
23.         
    , U4 Q7 p' g; M0 I2 U' |  O! H
24.   pfifo = &fifo;
    $ i5 q" g- z8 L
25. 
    2 N: D5 M0 g  m* a: f
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    , o( \, {, ]8 g* M
27. 
    
28.   while (1)
    7 F! e0 y) L- j. ~
29.   {
    
30.         /*一次接收的缓存，重新发送*/
    8 i8 X2 I  a8 ?- J0 s1 X7 `9 l
31.                 if(!FIFO_IsEmpty(pfifo))
    
32.                 {
    
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    . V) n( Z+ z( j7 M8 o4 |2 Q! x/ H
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    6 W/ G$ r3 X- c8 i3 V! f
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    ( p7 q' F, r9 I
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    7 Y& |5 L, z7 \; O% H
37.                 }
    
38.   }
    ! e! c2 J3 F- ]4 p# R
39. }

复制代码

测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！

* f% L  g/ A* U* C; S* S* r! C9 O% T0 V
, h( ~! B& O1 L: P" F; y$ x问：关于 stm32 HardFault_Handler问题处理？
% U( G* u) t& u9 ~
/ v8 Z4 A. L! jANS：

        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，

最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！
1 Y# N3 R( ^4 M: `

1. pfifo = &fifo;

复制代码

/ B" X  |- y: s8 Y! a' J$ B* s. R$ o

  M- o/ U7 d. E