一、STM32CubeMX开发
1.1 新建工程
file -> new project

选择芯片-> stm32 core内核         

                   stm32 series 系列

                   stm32  line

                   stm32  package

选择芯片根据自身需求去选择，目前该项目是stm32f0系列

                    stm32 core内核         M0

                   stm32 series 系列      F0

                   stm32  line                 F0X1

                   stm32  package         TSSOP 20

1.2 配置 USART1
配置 USART1 的模式为 Asynchronous，即异步串口模式

1.3 配置串口参数
根据需要设置波特率和数据宽度等参数，在此使用 9600，8，N，1

1.4 设置DMA

1.5 添加串口中断

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

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

二、代码部分
2.1  接收中断处理
2.1.1 接收固定长度：（舍弃）
只有接收缓存到固定长度才会触发中断
串口接收回调函数

1. uint8_t aRxBuffer[RXBUFFERSIZE];
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    10
   
4. 
   
5. 
   
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);
    
11.         HAL_UART_Receive_DMA(&huart1, (uint8_t *)aRxBuffer, RXBUFFERSIZE);
    
12.   HAL_UART_Receive_IT(&huart1, (uint8_t *)aRxBuffer,1);
    
13. 
    
14. }
    
15. 
    
16. void USART1_IRQHandler(void)
    
17. {
    
18.   HAL_UART_IRQHandler(&huart1);
    
19. }
    
20. 
    
21. 
    
22. static void MX_USART1_UART_Init(void)
    
23. {
    
24. 
    
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;
    
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();
    
38.   }  
    
39.         
    
40.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
41.   {
    
42.     Error_Handler();
    
43.   }
    
44.         
    
45.         UartrxReady=RESET;
    
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时，才触发接收回调函数。

2.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;
   
6.   huart1.Init.StopBits = UART_STOPBITS_1;
   
7.   huart1.Init.Parity = UART_PARITY_NONE;
   
8.   huart1.Init.Mode = UART_MODE_TX_RX;
   
9.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
   
10.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
    
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)
    
14.   {
    
15.     Error_Handler();
    
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    
20.     Error_Handler();
    
21.   }
    
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.   {
    
27.     Error_Handler();
    
28.   }
    
29.         
    
30. }

复制代码

空闲中断函数：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    30
   
4. 
   
5. void USAR_UART_IDLECallback(UART_HandleTypeDef *huart)
   
6. {
   
7.     HAL_UART_DMAStop(&huart1);
   
8. 
   
9.     uint8_t data_length  = RXBUFFERSIZE - __HAL_DMA_GET_COUNTER(&hdma_usart1_rx);
   
10. 
    
11. 
    
12.     HAL_UART_Transmit(&huart1,aRxBuffer,data_length,0x200);
    
13. 
    
14.     memset(aRxBuffer,0x00,data_length);
    
15.     data_length = 0;
    
16.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
    
17. }
    
18. 
    
19. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
20. {
    
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);
    
27.         }
    
28.     }
    
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)
    
35. {
    
36.     HAL_UART_IRQHandler(&huart1);
    
37.     USER_UART_IRQHandler(&huart1);
    
38. }

复制代码

可实现不定长的接收！

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

三、使用ringbuffer实现任意数据类型的FIFO处理接收数据
使用原因：

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

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

① fifo头文件：

1. #ifndef        __FIFO_H_
   
2. #define        __FIFO_H_
   
3. 
   
4. #pragma pack(4)
   
5. typedef struct FIFO_Type_STRU
   
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;                        // 缓存区
    
13. }FIFO_Type;
    
14. #pragma pack()
    
15. 
    
16. /********************************************************************//**
    
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
    
23. *********************************************************************/
    
24. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth);
    
25. 
    
26. /********************************************************************//**
    
27. * @brief       向FIFO添加一个元素
    
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. 
    
34. /********************************************************************//**
    
35. * @brief       向FIFO添加多个元素
    
36. * @param[in]   pFIFO: FIFO指针
    
37. * @param[in]        pValues: 要添加的元素指针
    
38. * @param[in]        bytesToAdd: 要添加元素的长度
    
39. * @return      实际添加的元素个数
    
40. *********************************************************************/
    
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: 存放要读取的元素指针
    
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    
49. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue);
    
50. 
    
51. /********************************************************************//**
    
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. 
    
61. /********************************************************************//**
    
62. * @brief       清空FIFO
    
63. * @param[in]   pFIFO: FIFO指针
    
64. * @return      None
    
65. *********************************************************************/
    
66. void FIFO_Clear(FIFO_Type *pFIFO);
    
67. 
    
68. 
    
69. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO);
    
70. 
    
71. #endif

复制代码

② fifo.c程序主体

1. #include <string.h>
   
2. #include "fifo.h"
   
3. 
   
4. 
   
5. /********************************************************************//**
   
6. * @brief       FIFO初始化
   
7. * @param[in]   pFIFO: FIFO指针
   
8. * @param[in]        pBuff: FIFO中缓存
   
9. * @param[in]        elementBytes:FIFO每个元素的字节数
   
10. * @param[in]        depth: FIFO深度
    
11. * @return      None
    
12. *********************************************************************/
    
13. void FIFO_Init(FIFO_Type *pFIFO, void *pBuff, unsigned int elementBytes, unsigned int depth)
    
14. {
    
15.         pFIFO->Buff = pBuff;
    
16.         pFIFO->ElementBytes = elementBytes;
    
17.         pFIFO->Depth = depth;
    
18.         pFIFO->Head = 0;
    
19.         pFIFO->Tail = 0;
    
20.         pFIFO->Counter = 0;
    
21. }
    
22. 
    
23. /********************************************************************//**
    
24. * @brief       判断FIFO是否为空
    
25. * @param[in]   pFIFO: FIFO指针
    
26. * @return      1-TRUE or 0-FALSE
    
27. *********************************************************************/
    
28. unsigned char FIFO_IsEmpty(FIFO_Type *pFIFO)
    
29. {
    
30.         return (pFIFO->Counter == 0);
    
31. }
    
32. 
    
33. /********************************************************************//**
    
34. * @brief       判断FIFO是否已满
    
35. * @param[in]   pFIFO: FIFO指针
    
36. * @return      TRUE or FALSE
    
37. *********************************************************************/
    
38. unsigned char FIFO_IsFull(FIFO_Type *pFIFO)
    
39. {
    
40.         return (pFIFO->Counter == pFIFO->Depth);
    
41. }
    
42. 
    
43. /********************************************************************//**
    
44. * @brief       向FIFO添加一个元素
    
45. * @param[in]   pFIFO: FIFO指针
    
46. * @param[in]        pValue: 要添加的元素
    
47. * @return      1-TRUE or 0-FALSE
    
48. *********************************************************************/
    
49. unsigned char FIFO_AddOne(FIFO_Type *pFIFO, void *pValue)
    
50. {
    
51.         unsigned char *p;
    
52. 
    
53.         if (FIFO_IsFull(pFIFO))
    
54.         {
    
55.                 return 0;
    
56.         }
    
57. 
    
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)
    
63.         {
    
64.                 pFIFO->Tail = 0;
    
65.         }
    
66.         pFIFO->Counter ++;
    
67.         return 1;
    
68. }
    
69. 
    
70. /********************************************************************//**
    
71. * @brief       向FIFO添加多个元素
    
72. * @param[in]   pFIFO: FIFO指针
    
73. * @param[in]        pValues: 要添加的元素指针
    
74. * @param[in]        bytesToAdd: 要添加元素的长度
    
75. * @return      实际添加的元素个数
    
76. *********************************************************************/
    
77. unsigned int FIFO_Add(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToAdd)
    
78. {
    
79.         unsigned char *p;
    
80.         unsigned int cnt = 0;
    
81. 
    
82.         p = (unsigned char *)pValues;
    
83.         while(bytesToAdd --)
    
84.         {
    
85.                 if (FIFO_AddOne(pFIFO, p))
    
86.                 {
    
87.                         p += pFIFO->ElementBytes;
    
88.                         cnt++;
    
89.                 }
    
90.                 else
    
91.                 {
    
92.                         break;
    
93.                 }
    
94.         }
    
95. 
    
96.         return cnt;
    
97. }
    
98. 
    
99. /********************************************************************//**
    
100. * @brief       从FIFO读取一个元素
     
101. * @param[in]   pFIFO: FIFO指针
     
102. * @param[in]        pValue: 存放要读取的元素指针
     
103. * @return      1-TRUE or 0-FALSE
     
104. *********************************************************************/
     
105. unsigned char FIFO_GetOne(FIFO_Type *pFIFO, void *pValue)
     
106. {
     
107.         unsigned char *p;
     
108.         if (FIFO_IsEmpty(pFIFO))
     
109.         {
     
110.                 return 0;
     
111.         }
     
112. 
     
113.         p = (unsigned char *)pFIFO->Buff;
     
114.         memcpy(pValue, p + pFIFO->Head * pFIFO->ElementBytes, pFIFO->ElementBytes);
     
115. 
     
116.         pFIFO->Head ++;
     
117.         if (pFIFO->Head >= pFIFO->Depth)
     
118.         {
     
119.                 pFIFO->Head = 0;
     
120.         }
     
121.         pFIFO->Counter --;
     
122. 
     
123.         return 1;
     
124. }
     
125. 
     
126. /********************************************************************//**
     
127. * @brief       从FIFO读取多个元素
     
128. * @param[in]   pFIFO: FIFO指针
     
129. * @param[out]        pValues: 存放要读取的元素指针
     
130. * @param[in]        bytesToRead: 要读取的元素长度
     
131. * @return      实际读取的元素个数
     
132. *********************************************************************/
     
133. unsigned int FIFO_Get(FIFO_Type *pFIFO, void *pValues, unsigned int bytesToRead)
     
134. {
     
135.         unsigned int cnt = 0;
     
136.         unsigned char *p;
     
137. 
     
138.         p = pValues;
     
139.         while(bytesToRead--)
     
140.         {
     
141.                 if (FIFO_GetOne(pFIFO, p))
     
142.                 {
     
143.                         p += pFIFO->ElementBytes;
     
144.                         cnt++;
     
145.                 }
     
146.                 else
     
147.                 {
     
148.                         break;
     
149.                 }
     
150.         }
     
151. 
     
152.         return cnt;
     
153. }
     
154. 
     
155. /********************************************************************//**
     
156. * @brief       清空FIFO
     
157. * @param[in]   pFIFO: FIFO指针
     
158. * @return      None
     
159. *********************************************************************/
     
160. void FIFO_Clear(FIFO_Type *pFIFO)
     
161. {
     
162.         pFIFO->Counter = 0;
     
163.         pFIFO->Head = 0;
     
164.         pFIFO->Tail = 0;
     
165. }

复制代码

③ 串口初始化

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;
   
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)
    
14.   {
    
15.     Error_Handler();
    
16.   }  
    
17.         
    
18.         if (HAL_UART_Init(&huart1) != HAL_OK)
    
19.   {
    
20.     Error_Handler();
    
21.   }
    
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.   {
    
27.     Error_Handler();
    
28.   }
    
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);
   
6.         
   
7.         FIFO_Add(pfifo, aRxBuffer, data_length);
   
8.     data_length = 0;
   
9.     HAL_UART_Receive_DMA(&huart1, (uint8_t*)aRxBuffer, RXBUFFERSIZE);
   
10. }
    
11. 
    
12. void USER_UART_IRQHandler(UART_HandleTypeDef *huart)
    
13. {
    
14.     if(USART1 == huart1.Instance)
    
15.     {
    
16.         if(RESET != __HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
    
17.         {
    
18.             __HAL_UART_CLEAR_IDLEFLAG(&huart1);
    
19.             USAR_UART_IDLECallback(huart);
    
20.         }
    
21.     }
    
22. }
    
23. 
    
24. /**
    
25.   * @brief This function handles USART1 global interrupt / USART1 wake-up interrupt through EXTI line 25.
    
26.   */
    
27. void USART1_IRQHandler(void)
    
28. {
    
29.   HAL_UART_IRQHandler(&huart1);
    
30.   USER_UART_IRQHandler(&huart1);
    
31. }

复制代码

⑤ 主函数调用：

1. #define TXBUFFERSIZE                    30
   
2. /* Size of Reception buffer */
   
3. #define RXBUFFERSIZE                    TXBUFFERSIZE
   
4. #define RXFIFOBUFFERSIZE                TXBUFFERSIZE * 5
   
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. 
    
16. int main(void)
    
17. {
    
18.   /*此处省略硬件初始化*/
    
19.   if(HAL_UART_Transmit(&huart1, (uint8_t*)aTxBuffer, TXBUFFERSIZE, 200)!= HAL_OK)
    
20.   {
    
21.     Error_Handler();
    
22.   }
    
23.         
    
24.   pfifo = &fifo;
    
25. 
    
26.   FIFO_Init(pfifo, aRxFIFOBuffer, sizeof(uint8_t), RXFIFOBUFFERSIZE);
    
27. 
    
28.   while (1)
    
29.   {
    
30.         /*一次接收的缓存，重新发送*/
    
31.                 if(!FIFO_IsEmpty(pfifo))
    
32.                 {
    
33.                         uint8_t a[100]; //存放读取fifobuffer的数据
    
34.                         int i = pfifo->Counter;//先保存接收缓存的数据个数
    
35.                         FIFO_Get(pfifo, &a, pfifo->Counter);
    
36.                         HAL_UART_Transmit(&huart1, a, i, 200); //将接收的缓存数据再次发送，判断有无误码率
    
37.                 }
    
38.   }
    
39. }

复制代码

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

问：关于 stm32 HardFault_Handler问题处理？

ANS：

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

最后，发现是在fifo_init 调用的指针，未赋地址。添加之后，解决了！

1. pfifo = &fifo;

复制代码