一、STM32CubeMX开发
1.1 新建工程
- A& i4 U5 `* {: Ifile -> new project
1 t0 Q5 h5 L4 J: J' n
' J, W! }1 f9 a3 i  |选择芯片-> stm32 core内核         
" y: a5 [$ o0 m- x( @4 i
                   stm32 series 系列
( i4 Z1 _, P' Z9 U6 A3 w+ `
                   stm32  line

                   stm32  package
+ n7 l- o( c  g/ j) z
. z/ y: {4 V; j. J& J, _选择芯片根据自身需求去选择，目前该项目是stm32f0系列
! J2 ^1 Z& r/ M  s9 _
/ b  c/ |( _/ T5 R                    stm32 core内核         M0
/ E; T$ k% j) o
8 G  `! }9 O+ a                   stm32 series 系列      F0
; f. a. V6 h- m5 `! i7 C# V, M
) |1 e# U- w3 w                   stm32  line                 F0X1
/ ~( K- e6 Y9 {0 p
2 F1 T# t( q3 L9 l; p, @( X7 G                   stm32  package         TSSOP 20
  Q: D8 h  z% M6 G' ?7 A
1.2 配置 USART1
1 k) N2 _( }# K5 t配置 USART1 的模式为 Asynchronous，即异步串口模式
" o3 O& |: x2 w$ R

1.3 配置串口参数
/ ^; S& N3 z- ^" J/ S 根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1
1 y4 S, o6 X3 D% ?
% P% }+ z2 r2 k$ h+ f

1 E" `  G9 e* U- D: g9 v
1.4 设置DMA

% p* b& }, E0 c. \ 1.5 添加串口中断

4 ]3 r" }% w; c6 U1 `+ B: h
2 R+ ]9 V* ~) L 1.6 生成源代码。
在界面中输入工程名，保存路径，工程 IDE 类型，点 GENERATE CODE 即可。

: i7 J# J3 S! e9 A. M: c9 A0 X
生成代码完成后可选择打开工程。
% c: b$ p0 Y3 Z( U3 U, X- o9 x

" O, k0 r# Q4 y1 D4 s$ H
二、代码部分
1 z4 h. P' y% r2.1  接收中断处理
2.1.1 接收固定长度：（舍弃）
5 {* f/ {8 x. [  x* c* k- ^7 {只有接收缓存到固定长度才会触发中断
+ O) v' f$ L& F; v6 |* _, O8 r( N/ Z串口接收回调函数

( H9 Y0 w. K/ ^1 v/ `

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   * J  }3 V4 L2 }% _1 T3 |6 h
2. /* Size of Reception buffer */
   + B$ @5 g; h  E1 X  g  z
3. #define RXBUFFERSIZE                    10
   5 x8 \  K5 K* i4 S5 ?+ ?2 c
4. 
   
5. 
   
6. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *UartHandle)
   
7. {
   - O" k; y$ p1 W! @  F) F9 {% ]* E
8.   /* Set transmission flag: trasfer complete*/
   % S: Y+ }9 i) _3 W! {
9.   UartrxReady = SET;
   
10.         HAL_UART_Transmit(&huart1, aRxBuffer, 10, 0x200);
    5 E0 H$ M  Y& K7 x- v% W0 i
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    3 Y4 S4 ]  X3 s: K# M/ V/ U
13. 
    ! y& u8 `2 G! W
14. }
    
15. 
    - A: v% W& o+ p- b
16. void USART1_IRQHandler(void)
    
17. {
    
18.   HAL_UART_IRQHandler(&huart1);
    
19. }
    % e% [- z! X! ^! j6 ?& a' y
20. 
    
21. 
    3 O% `* m& a' }/ I8 m  Q: `( c
22. static void MX_USART1_UART_Init(void)
    
23. {
    + e  K: l8 {7 W0 H. V+ ]4 ~% x1 R' e
24. 
    
25.   huart1.Instance = USART1;
    $ d( c$ C9 v& A
26.   huart1.Init.BaudRate = 9600;
    " L1 [+ C0 s: F# q$ A
27.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
    1 Y9 p& \; G9 N4 c6 B) N1 v8 E* m+ M
28.   huart1.Init.StopBits = UART_STOPBITS_1;
    0 O7 u9 |  ~0 O# }4 d
29.   huart1.Init.Parity = UART_PARITY_NONE;
    
30.   huart1.Init.Mode = UART_MODE_TX_RX;
      G- S& ?8 K. g6 r1 Y8 s
31.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    
32.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    ( P( [/ W* q" B9 y
33.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
34.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    % G  \+ W3 F* p; V. {2 Y
35.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    0 i2 c# E; B4 j5 o# D
36.   {
    
37.     Error_Handler();
    / Q" k% v& {) D+ Y8 `
38.   }  
    
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
41.   {
    4 s0 l7 y9 j( q2 s$ l
42.     Error_Handler();
    
43.   }
    0 @1 b1 G8 H" A4 R3 A
44.         
    8 v8 m9 u$ y, K& ^0 x, O
45.         UartrxReady=RESET;
    ; h0 q5 Z) u2 j& u
46.   /* USER CODE BEGIN USART1_Init 2 */
    . A# T0 @: O# S0 q+ Z
47.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    6 y- d( ~4 g0 `" K) l
48.   {
    
49.     Error_Handler();
    
50.   }
    * d1 L8 J1 l1 n
51.         
    2 N( ^4 O0 E5 }- S) Y4 S" }- t+ Y5 W
52.   /* USER CODE END USART1_Init 2 */
    3 c7 ?* a4 M' R$ u' y9 a
53. }

复制代码

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

3 n' _$ u0 R3 K9 D

2.1.2 编写空闲中断函数接收不定长
4 ?0 R/ R- h1 OUSART1初始化：

1. static void MX_USART1_UART_Init(void)
   
2. {
   
3.   huart1.Instance = USART1;
   % A2 ^2 ^2 M7 g" @
4.   huart1.Init.BaudRate = 9600;
   9 P! z* N* V8 n5 F( `. L% V
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   5 a9 V. i) o9 y1 ]
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   / o8 X0 L$ ?2 B' Y; G
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   7 W+ X3 D! T3 Q( w/ Q) q" o
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    : I" {  i) p. O+ X; s: ]- \
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    
14.   {
    
15.     Error_Handler();
      ?8 ]( {% @# I/ c' Q! V
16.   }  
    . I0 J5 k1 e( \" g$ x
17.         
    1 `% s" y7 [" {* Y8 X% q; C
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    6 z* G% V3 x  q
19.   {
    + e8 @1 [' y9 Z% e0 h" B6 t
20.     Error_Handler();
    & l1 t& v2 B- C6 h* K! j
21.   }
      g' A) c$ a! W$ [  @" B% [: B
22. 
    & H2 y4 N7 m9 I* v. A7 [$ h
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    
24.   /* USER CODE BEGIN USART1_Init 2 */
    9 m  L1 u' L. c* D: H9 ~! w
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    ! q$ S( ]( W: K; N3 {
26.   {
    
27.     Error_Handler();
    
28.   }
    2 \7 ]1 q( M/ b7 {) L4 e* r2 j
29.         
    7 R8 t) o# F9 s4 f" m/ ]& ^2 s
30. }

复制代码

空闲中断函数：

1. #define TXBUFFERSIZE                    30
   . d2 i! v/ U+ x% L
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    30
   
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   6 ~1 K$ m/ ~7 `3 i
6. {
   8 t6 W4 j, h0 d3 }6 A' x
7.     HAL_UART_DMAStop(&huart1);
   
8. 
   
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   8 K, g3 p1 a5 n% g3 A" J
10. 
    
11. 
    $ }* K/ \9 s7 |; {7 l
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    - X3 z/ a1 V7 D! m6 G" d
13. 
    & G4 K  l# F  ^0 _% l+ o
14.     memset(aRxBuffer,0x00,data_length);
    
15.     data_length = 0;
    
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    5 ], I# A9 S5 ^# l! ]( c2 f9 b
17. }
    5 p& b# a$ f* p3 ]& V  _: P3 X" F' l
18. 
    5 l3 V% ~0 [; ^0 L3 ^9 e5 c! u  J
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
20. {
    
21.     if(USART1 == huart1.Instance)
    * S4 K" J! G! E/ |0 U8 G' M
22.     {
    
23.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
24.         {
    - U+ |4 ?# {6 p4 |
25.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    6 l8 [9 k0 m1 r: i0 G
26.             USAR_UART_IDLECallback(huart);
    3 Q% A( A9 c& r& e+ Y4 t* D0 `
27.         }
    
28.     }
    0 ?. p2 ]4 g; A: A$ E  _5 h
29. }
    
30. 
    
31. /**
    
32.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
33.   */
    
34. void USART1_IRQHandler(void)
    5 P4 N. U/ X9 o) n
35. {
    1 a, q( ^% z# F5 q! u
36.     HAL_UART_IRQHandler(&huart1);
    
37.     USER_UART_IRQHandler(&huart1);
    2 g6 D6 Y4 }% n1 c$ t
38. }

复制代码

, V; {/ y7 V+ T- a) b7 G& B可实现不定长的接收！

1 ?6 w4 a$ H4 y" d7 O 注意：
在中断中，尽量处理简单，不要做过多的处理，如发射，可以在函数外执行。

三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
使用原因：
) n! F9 l- ^3 e" ~
        虽然将数据保存在DMA接收缓存中，但在处理接收数据时，可能存在接收新的数据在调用数据完覆盖了接收缓存，导致调用数据时候会出现与原计划的处理不同的问题。
5 @) o6 }6 l6 ~3 n4 E8 M
        因此，使用ringbuffer将DMA接收缓存，以防数据的被覆盖

* I/ d! R( r  j2 ]6 ?- X4 {① fifo头文件：
% H6 p! Y0 O' x, y9 i

1. #ifndef        __FIFO_H_
   
2. #define        __FIFO_H_
   
3. 
   7 [* n7 q2 H/ x& P! }) ?2 n
4. #pragma pack(4)
   4 ?4 S+ Q/ J* s3 n4 U
5. typedef struct FIFO_Type_STRU
   
6. {
   
7.         unsigned int                        Depth;                        // Fifo深度
   1 u; Q) b3 @- V" N) {4 m+ q9 U& l
8.         volatile unsigned int        Head;                        // Head为起始元素
   ! ~* T, i6 b3 Z3 }7 G1 z
9.         volatile unsigned int        Tail;                        // Tail-1为最后一个元素
   
10.         volatile unsigned int        Counter;                // 元素个数
    
11.         unsigned int                        ElementBytes;        // 每个元素的字节数element
    0 K# f+ }4 x  F$ x5 c6 M
12.         void                                        *Buff;                        // 缓存区
    
13. }FIFO_Type;
    
14. #pragma pack()
    
15. 
    
16. /********************************************************************//**
    1 w  z% F% h* n! f" ]
17. * @brief       FIFO初始化
    0 K% }6 X7 T0 z# @, G0 W
18. * @param[in]   pFIFO: FIFO指针
    
19. * @param[in]        pBuff: FIFO中缓存
    - X+ r' P# X+ u8 x) y! O3 b8 X
20. * @param[in]        elementBytes:FIFO每个元素的字节数
    
21. * @param[in]        depth: FIFO深度
    
22. * @return      None
    
23. *********************************************************************/
    
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    ; l& z5 \/ d3 |
25. 
    
26. /********************************************************************//**
    ! ]$ ]7 @% l( w7 [3 C. p
27. * @brief       向FIFO添加一个元素
    
28. * @param[in]   pFIFO: FIFO指针
    
29. * @param[in]        pValue: 要添加的元素
    , @# `& E# a1 ?) Y* D5 X' {" F
30. * @return      1-TRUE or 0-FALSE
    
31. *********************************************************************/
    
32. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue);
    1 }9 X1 K$ O9 t
33. 
    & V5 t$ v! Z8 E6 q; T) Z. }
34. /********************************************************************//**
    
35. * @brief       向FIFO添加多个元素
    
36. * @param[in]   pFIFO: FIFO指针
    7 |" ]- x3 T' h& @: z
37. * @param[in]        pValues: 要添加的元素指针
    ' o. I1 A' N. b8 R
38. * @param[in]        bytesToAdd: 要添加元素的长度
    
39. * @return      实际添加的元素个数
    / b, ^' z/ Y" @4 a
40. *********************************************************************/
    + s. H4 d- F) D3 V8 Y) g( Y
41. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd);
    , O% @. s) F! @9 n
42. 
    : D9 u! i: l9 ]# Z
43. /********************************************************************//**
    ) @; n/ v. T3 J$ Y! _6 A6 ?
44. * @brief       从FIFO读取一个元素
    ( K% s& _( y1 F+ U6 J& f
45. * @param[in]   pFIFO: FIFO指针
    % q' O/ J) p' O; {7 Y4 ?
46. * @param[in]        pValue: 存放要读取的元素指针
    8 g7 o. U) |9 e8 u, ~& Z$ |
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    / \/ }0 P9 _  o& k( T$ `+ f
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    
50. 
    
51. /********************************************************************//**
    0 C6 y) b# u/ `5 X
52. * @brief       从FIFO读取多个元素
    
53. * @param[in]   pFIFO: FIFO指针
    
54. * @param[out]        pValues: 存放要读取的元素指针
    
55. * @param[in]        bytesToRead: 要读取的元素长度
    3 A# c8 u2 s. r' F, i
56. * @return      实际读取的元素个数
    ; u8 B$ s* P3 E! k! W  t
57. *********************************************************************/
    
58. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead);
    0 d; v2 w& _& J: H
59. 
    " b  S1 {# w4 b, t
60. 
    ! L* y$ C8 r) ?
61. /********************************************************************//**
    
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    9 J5 M$ Y' H  H0 @  L
64. * @return      None
    
65. *********************************************************************/
    2 S1 V7 H6 \& _1 X9 L5 u. H& a" ^& P+ Z
66. void FIFO_Clear(FIFO_Type *pFIFO);
    ; g; U" C6 g. S; N$ d+ x+ l! g
67. 
    - i8 v$ k8 p: o/ p9 Q
68. 
    " x+ b9 q0 y- P, m- \
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    1 @% P# c% i' u) Z
70. 
    $ H* S) Q/ K- n  }* Q2 n, M% Z
71. #endif

复制代码

; G% n  d: `! u! D② fifo.c程序主体
; {; O3 i( ~- U% O* @- L: u

1. #include <string.h>
   
2. #include "fifo.h"
   
3. 
   % ]+ l4 q. W" v7 B
4. 
   : ]9 I. c" L# c% n& h: [
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   3 p0 y7 u! l* _6 u3 f
7. * @param[in]   pFIFO: FIFO指针
   
8. * @param[in]        pBuff: FIFO中缓存
   6 U! c/ b3 ?! p' @/ v* H' x
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   2 i2 \5 P- F* y: V) ^
10. * @param[in]        depth: FIFO深度
    
11. * @return      None
    ' a' ]' V0 j3 s
12. *********************************************************************/
    
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    $ n; y; u: n+ W" O5 I" [
14. {
    
15.         pFIFO->Buff = pBuff;
    + @6 I; D8 ~' E/ M
16.         pFIFO->ElementBytes = elementBytes;
    
17.         pFIFO->Depth = depth;
    
18.         pFIFO->Head = 0;
    1 S* n0 o& ^' F! _' A
19.         pFIFO->Tail = 0;
    ( {* @& ]  S0 D8 G* {* x
20.         pFIFO->Counter = 0;
    
21. }
      E& Y' j! q8 h. ]; P0 A
22. 
    7 u7 V1 p: G  w1 y+ U
23. /********************************************************************//**
    
24. * @brief       判断FIFO是否为空
      q0 I3 s7 B9 P, G7 b
25. * @param[in]   pFIFO: FIFO指针
    
26. * @return      1-TRUE or 0-FALSE
    ! ]' i9 b; `( q, D- o9 Q3 y
27. *********************************************************************/
    8 M! D0 Z6 [, ^! x; {' v% P$ l
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    # H* b5 \7 E* J% Y1 `% v
29. {
    
30.         return (pFIFO->Counter == 0);
    
31. }
    ) }4 m7 z' b0 Y, @) u% N
32. 
    
33. /********************************************************************//**
    $ s8 |4 c+ s, \% T3 n; ?
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    
36. * @return      TRUE or FALSE
    
37. *********************************************************************/
    ' n6 {" P6 `0 h
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    
39. {
    
40.         return (pFIFO->Counter == pFIFO->Depth);
    
41. }
    ; g7 r4 W" U/ m& y: o9 N' c4 v
42. 
    ' ^9 o1 U! j3 a- `
43. /********************************************************************//**
    4 J2 O  K: Y! N; N3 V/ Q( c
44. * @brief       向FIFO添加一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    : ]' g% x7 W$ a  Q+ k, f. E
46. * @param[in]        pValue: 要添加的元素
    1 V% q- k! j7 X
47. * @return      1-TRUE or 0-FALSE
    5 ?: n: F6 C( b% N5 w: w& d: a1 n
48. *********************************************************************/
    ; m, j$ R+ ~" r; ~. j
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
      E& o; h0 E5 j* b6 o
50. {
    , q: U+ N  n5 e; P
51.         unsigned char *p;
    
52. 
    9 l! H' N2 o" V% a" Q7 D& n
53.         if (FIFO_IsFull(pFIFO))
    2 |: O1 o8 m$ e8 A6 @
54.         {
    
55.                 return 0;
      Y( R' S& Q+ ?) N3 k
56.         }
    
57. 
    # o5 ~# t8 ^0 V, ^0 D
58.         p = (unsigned char *)pFIFO->Buff;
    
59.         memcpy(p + pFIFO->Tail * pFIFO->ElementBytes, (unsigned char *)pValue, pFIFO->ElementBytes);
    
60.         
    
61.         pFIFO->Tail ++;
    
62.         if (pFIFO->Tail >= pFIFO->Depth)
    : p* g/ {9 ?( S/ X5 O
63.         {
    
64.                 pFIFO->Tail = 0;
    
65.         }
    
66.         pFIFO->Counter ++;
    7 [5 |" w$ a1 H7 Z4 I) M, Y: f
67.         return 1;
    " Y) ?2 b) _( i
68. }
    ! N; l) h7 S) s  X0 ?4 n2 x/ X$ u
69. 
    
70. /********************************************************************//**
    - e; w( ^9 P: d" s
71. * @brief       向FIFO添加多个元素
    5 k6 V) d5 f8 @1 ]: Z% O
72. * @param[in]   pFIFO: FIFO指针
    
73. * @param[in]        pValues: 要添加的元素指针
    ! ^1 n0 G" ]/ k5 |
74. * @param[in]        bytesToAdd: 要添加元素的长度
      z& v5 V4 w" U5 d4 g8 D( M4 _1 T
75. * @return      实际添加的元素个数
    8 W( j1 F  ^# E# K
76. *********************************************************************/
    
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    
78. {
    ; X6 G( @% v7 I( `/ s+ q
79.         unsigned char *p;
    
80.         unsigned int cnt = 0;
    ! R! C* U; \+ @' y% i
81. 
    
82.         p = (unsigned char *)pValues;
    
83.         while(bytesToAdd --)
    ' y* ?2 f1 e: X' u; ]# O9 r
84.         {
    # j1 n; p9 W# J( K' U% N6 g
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    6 i) J+ R) T$ C2 [8 i5 E1 J
87.                         p += pFIFO->ElementBytes;
    : a1 z# B, |6 G/ Y: W3 C3 U1 p
88.                         cnt++;
    
89.                 }
    
90.                 else
    
91.                 {
    % O) ~2 S, A' g- X. Z
92.                         break;
    
93.                 }
    
94.         }
    5 D) ^+ W, E. u. i- h
95. 
    
96.         return cnt;
    / a# q& g& S4 r
97. }
    $ l7 v9 {* G- `
98. 
    ) S& `* C3 v8 _6 V6 N
99. /********************************************************************//**
    
100. * @brief       从FIFO读取一个元素
     $ [# R$ S" r- ^: s
101. * @param[in]   pFIFO: FIFO指针
     : N. b! j% y& f5 W: W0 B$ g+ M/ A
102. * @param[in]        pValue: 存放要读取的元素指针
     4 u$ N& u3 y( H
103. * @return      1-TRUE or 0-FALSE
     6 o4 v# g, \' d3 L. C( C0 S
104. *********************************************************************/
     
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     4 W5 F+ b  B4 Z0 o7 N. z
106. {
     - E. ~) o* v  s2 d! r
107.         unsigned char *p;
     
108.         if (FIFO_IsEmpty(pFIFO))
     8 l1 i) d; U7 z; h8 F1 F
109.         {
     
110.                 return 0;
     / w2 \& K) b+ a/ F( Y# m$ e
111.         }
     
112. 
     
113.         p = (unsigned char *)pFIFO->Buff;
     3 ^% |" N# b% }8 g. |5 E4 [
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     5 q5 C8 f+ N2 H& w' z
115. 
     / W% w! n8 U# W& Q& [
116.         pFIFO->Head ++;
     ' C, Q: k9 v! n5 f2 p% b7 u; u
117.         if (pFIFO->Head >= pFIFO->Depth)
     
118.         {
     9 d7 G$ F$ @5 j$ L2 a
119.                 pFIFO->Head = 0;
     
120.         }
     
121.         pFIFO->Counter --;
     
122. 
     " ^2 R+ A2 ^4 K( j! K+ E: e- H
123.         return 1;
     8 i# b9 N1 f3 L9 |
124. }
     
125. 
     4 F/ q- c8 ?5 |7 o
126. /********************************************************************//**
     
127. * @brief       从FIFO读取多个元素
     / ]4 `7 h: i* a; W, p
128. * @param[in]   pFIFO: FIFO指针
     ) \, N/ Q- c5 F
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     
131. * @return      实际读取的元素个数
     
132. *********************************************************************/
     3 _- U7 M; V4 o- s
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     
135.         unsigned int cnt = 0;
     
136.         unsigned char *p;
     4 _7 G. R4 \5 G. t
137. 
     
138.         p = pValues;
     $ w7 J3 S, L. b5 T6 E# z  e* }
139.         while(bytesToRead--)
     
140.         {
     ; t: N" o- |% e4 x% }- A9 c
141.                 if (FIFO_GetOne(pFIFO, p))
     ! M/ a* I1 F1 o' p# U' y: R
142.                 {
     
143.                         p += pFIFO->ElementBytes;
     % H9 }7 `$ e( L
144.                         cnt++;
     * l7 x" g/ J# i
145.                 }
     ! i3 ?. j( n/ \- w. g: ]5 Z. V1 s
146.                 else
     
147.                 {
     
148.                         break;
     0 N/ }& B" Z" t
149.                 }
     + P5 t1 W0 B1 V% ]1 j8 }) q
150.         }
     * {5 ^( X$ M) W% L) N9 N
151. 
     4 t& E) ^0 p* u5 q9 v
152.         return cnt;
     - g6 V# T- d- N  q0 r* v  A* \
153. }
     5 V- U: ?6 [. K0 Q; h5 i* [
154. 
     
155. /********************************************************************//**
     
156. * @brief       清空FIFO
     3 Y* d9 c4 J9 W( D  U& \
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     
159. *********************************************************************/
     ! {$ h9 m  a$ S( ]. q! O. A  U
160. void FIFO_Clear(FIFO_Type *pFIFO)
     + z+ D" n' [$ `6 P4 S
161. {
     ) ]- |# ^' ]2 i+ p4 V4 i
162.         pFIFO->Counter = 0;
     # z2 q; Z1 K- C9 y* E9 s! |7 U+ c  z
163.         pFIFO->Head = 0;
     
164.         pFIFO->Tail = 0;
     
165. }

复制代码

4 ]2 O* A+ o5 z ③ 串口初始化

1. static void MX_USART1_UART_Init(void)
   
2. {
   
3.   huart1.Instance = USART1;
   
4.   huart1.Init.BaudRate = 9600;
   3 R4 g0 s8 t% o
5.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
   ; R' O" M3 h9 h- c5 m7 v7 j3 @' ^
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   ) ?1 i( ^% M& F8 m6 V- @
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   ; Q  ~2 ~  F3 A/ }
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
11.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
    9 w( s% e- S* H5 r
12.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
    5 W5 \' [' u$ B: j
13.   if(HAL_UART_DeInit(&huart1) != HAL_OK)
    
14.   {
    
15.     Error_Handler();
    2 a- l0 P7 N8 o! Z: ^* [3 c
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    3 F& J7 o8 |4 B% g7 O. Y
19.   {
    
20.     Error_Handler();
    
21.   }
    
22.         
    
23.         __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
      O7 a4 P  ^; Y& G
24.   /* USER CODE BEGIN USART1_Init 2 */
    
25.         if(HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE) != HAL_OK)
    
26.   {
    
27.     Error_Handler();
    , ]: d+ b/ u2 `/ q' Q& V: y( {$ N  Y
28.   }
    4 |( r' p. M$ k
29.         
    " o1 l, t8 K0 _/ t" o3 U- X
30. }

复制代码

④ 接收空闲中断
$ o) l4 _/ l4 Z

1. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
2. {
   
3.     HAL_UART_DMAStop(&huart1);
   * V& E, u  b4 q2 |* ?2 |" O. T
4. 
   , m& h0 ]$ ]: ~5 [
5.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   
6.         
   # q+ L% B+ W$ c( b; D& \
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   
8.     data_length = 0;
   
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   ! V+ `& H, P) F* M
10. }
    $ `' K6 p' C- O( R2 I4 k/ L0 v
11. 
    
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    6 C0 o8 W! P. @$ v& |
13. {
    : q1 g8 B9 m+ v# w6 M. H
14.     if(USART1 == huart1.Instance)
    0 @" d( i7 F7 `  y  T
15.     {
    
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    5 g6 M7 R) f- }0 O) Q
17.         {
    
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
19.             USAR_UART_IDLECallback(huart);
    
20.         }
    
21.     }
    & v8 q) Y$ Y8 k& j  h# g3 U$ u" w
22. }
    
23. 
    9 G! O1 f4 |9 ~; w# {  r
24. /**
    2 Z4 N7 p3 s8 H! X
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    4 O. n3 K5 ~" y. P  [! v0 t8 }
26.   */
    4 H" E: h: j2 R3 ?2 ]1 ]" v0 ~" Q
27. void USART1_IRQHandler(void)
    # y; u# f' q8 X( }
28. {
    % O" z9 P  a0 y' z
29.   HAL_UART_IRQHandler(&huart1);
    
30.   USER_UART_IRQHandler(&huart1);
    
31. }

复制代码

⑤ 主函数调用：

1. #define TXBUFFERSIZE                    30
   " f' d: O  U9 M
2. /* Size of Reception buffer */
   " F$ W( ~0 z, C; W
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   . {# P: h2 @% {
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   
5. 
   . ]4 |; ^  E; l/ q' \  X7 f" \
6. 
   
7. uint8_t aTxBuffer[] = " ****UART_TwoBoards communication based on DMA****";
   + n7 j" N& M; x( o2 v" K
8. 
   $ ]0 i1 Y. M5 E8 F) N6 ~5 }& K
9. /* Buffer used for reception */
   1 S2 v$ |& S. n5 B- O4 h$ @
10. uint8_t aRxBuffer[RXBUFFERSIZE];
    
11. 
    * {1 y/ |4 C( q
12. uint8_t aRxFIFOBuffer[RXFIFOBUFFERSIZE];
    
13. FIFO_Type        fifo;
    9 n. c! i1 n0 o9 b! ], y
14. FIFO_Type        *pfifo;
    3 Q; ]$ q5 \8 `6 j# R
15. 
    
16. int main(void)
    4 x( @( d* m; E" p
17. {
    
18.   /*此处省略硬件初始化*/
    , x. E0 [6 {# D$ E  }% R3 }/ i
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    - o0 C+ e# `$ A$ R1 J  {  i
20.   {
    % T; I% C  E, ^8 F( Z' v9 b' n2 D
21.     Error_Handler();
    1 s  L. r" l4 k+ x: |6 |/ ^1 @7 C8 e
22.   }
    
23.         
    
24.   pfifo = &fifo;
    ; C  Z4 p1 b! @( h( u
25. 
    8 O9 f1 y" L0 S
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    0 Q! U6 F) o& ?. M  j$ [( h
27. 
    
28.   while (1)
    
29.   {
    3 Y" x) z0 u- {3 u& F3 Q
30.         /*一次接收的缓存，重新发送*/
    
31.                 if(!FIFO_IsEmpty(pfifo))
    
32.                 {
    ) I6 r. H2 r; s; S
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    " I% {- P2 F9 P
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    + q3 S! h& z: x
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    , q: z; {# J( z1 \# W) l4 ^
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    
37.                 }
    
38.   }
    
39. }

复制代码

测试成功！可以在主函数对数据进行处理，不用担心缓存的覆盖！
, C/ j/ P9 H% K! ~, O' X

. l  n$ Z" P( _; ?: I8 ?0 Y
问：关于 stm32 HardFault_Handler问题处理？
* O+ Q( E# G4 j: ]+ U
ANS：

  a( V4 ]3 r3 V' q0 n1 x; ~6 R: C        在代码调试是，发现在执行fifo_init初始化，会进入HardFault_Handler，

6 o+ ?- D" b* T1 Y% b

/ F, x% k; B. D' j1 X( R2 h
5 _5 z/ f" a$ p9 J  h

3 G8 N9 _4 p  l( ~# c" d
9 J" O) {$ }2 J4 o 最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！
" J: Y; d9 w. p* h: O, O

1. pfifo = &fifo;

复制代码

1 q7 P4 N+ t; I8 `! y6 c2 x% Y